diff --git a/.bazelrc b/.bazelrc
index 3a09925..d231812 100644
--- a/.bazelrc
+++ b/.bazelrc
@@ -77,7 +77,8 @@
 # Show paths to a few more than just 1 target.
 build --show_result 5
 # Dump the output of the failing test to stdout.
-test --test_output=errors
+# Keep the default test timeouts except make 'eternal'=4500 secs
+test --test_output=errors --test_timeout=-1,-1,-1,4500
 
 build --sandbox_base=/dev/shm/
 build --experimental_multi_threaded_digest
diff --git a/WORKSPACE b/WORKSPACE
index 4a00be7..2113efe 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -76,6 +76,10 @@
     gstreamer_armhf_debs = "files",
 )
 load(
+    "//debian:gstreamer_arm64.bzl",
+    gstreamer_arm64_debs = "files",
+)
+load(
     "//debian:m4.bzl",
     m4_debs = "files",
 )
@@ -129,10 +133,18 @@
 
 generate_repositories_for_debs(opencv_amd64_debs)
 
-generate_repositories_for_debs(gstreamer_amd64_debs)
+generate_repositories_for_debs(
+    gstreamer_amd64_debs,
+    base_url = "https://www.frc971.org/Build-Dependencies/gstreamer_bullseye_amd64_deps",
+)
 
 generate_repositories_for_debs(gstreamer_armhf_debs)
 
+generate_repositories_for_debs(
+    gstreamer_arm64_debs,
+    base_url = "https://www.frc971.org/Build-Dependencies/gstreamer_bullseye_arm64_deps",
+)
+
 generate_repositories_for_debs(m4_debs)
 
 generate_repositories_for_debs(lzma_amd64_debs)
@@ -282,6 +294,9 @@
     #"//tools/cpp:cc-toolchain-cortex-m4f-k22",
     "//tools/python:python_toolchain",
     "//tools/go:noop_go_toolchain",
+    "//tools/rust:rust-toolchain-x86",
+    "//tools/rust:rust-toolchain-armv7",
+    "//tools/rust:rust-toolchain-arm64",
     "//tools/rust:rust-toolchain-roborio",
     "//tools/rust:noop_rust_toolchain",
     "//tools/ts:noop_node_toolchain",
@@ -817,19 +832,14 @@
     urls = ["https://github.com/bazelbuild/rules_webtesting/releases/download/0.3.5/rules_webtesting.tar.gz"],
 )
 
-http_archive(
+local_repository(
     name = "rules_rust",
-    sha256 = "531bdd470728b61ce41cf7604dc4f9a115983e455d46ac1d0c1632f613ab9fc3",
-    strip_prefix = "rules_rust-d8238877c0e552639d3e057aadd6bfcf37592408",
-    urls = [
-        # `main` branch as of 2021-08-23
-        "https://github.com/bazelbuild/rules_rust/archive/d8238877c0e552639d3e057aadd6bfcf37592408.tar.gz",
-    ],
+    path = "third_party/rules_rust",
 )
 
-load("@rules_rust//rust:repositories.bzl", "rust_repository_set")
+load("@rules_rust//rust:repositories.bzl", "rust_toolchain_repository")
 
-rust_repository_set(
+rust_toolchain_repository(
     name = "rust",
     edition = "2021",
     exec_triple = "x86_64-unknown-linux-gnu",
@@ -838,7 +848,9 @@
         "armv7-unknown-linux-gnueabihf",
         "aarch64-unknown-linux-gnu",
     ],
-    version = "1.56.1",
+    rustfmt_version = "1.58.1",
+    toolchain_name_prefix = "toolchain_for",
+    version = "1.58.1",
 )
 
 load("@io_bazel_rules_webtesting//web:repositories.bzl", "web_test_repositories")
@@ -975,8 +987,8 @@
 http_archive(
     name = "gstreamer_k8",
     build_file = "@//debian:gstreamer.BUILD",
-    sha256 = "4d74d4a82f7a73dc9fe9463d5fae409b17845eef7cd64ef9c4c4553816c53589",
-    url = "https://www.frc971.org/Build-Dependencies/gstreamer_amd64.tar.gz",
+    sha256 = "d4994261a432c188716f0bdf30fc3f0dff6727319d9c58e7156e2b3ed5105248",
+    url = "https://www.frc971.org/Build-Dependencies/gstreamer_1.20.1-1~bpo11+1_amd64.tar.gz",
 )
 
 http_archive(
@@ -986,6 +998,13 @@
     url = "https://www.frc971.org/Build-Dependencies/gstreamer_armhf.tar.gz",
 )
 
+http_archive(
+    name = "gstreamer_arm64",
+    build_file = "@//debian:gstreamer.BUILD",
+    sha256 = "42b414c565ffdbae3d2d7796a66da9de42a650de757fa6554fd624f0cc3aaa9b",
+    url = "https://www.frc971.org/Build-Dependencies/gstreamer_1.20.1-1~bpo11+1_arm64.tar.gz",
+)
+
 # Downloaded from:
 # https://files.pythonhosted.org/packages/64/a7/45e11eebf2f15bf987c3bc11d37dcc838d9dc81250e67e4c5968f6008b6c/Jinja2-2.11.2.tar.gz
 http_archive(
diff --git a/aos/configuration.fbs b/aos/configuration.fbs
index c0d67b0..7595167 100644
--- a/aos/configuration.fbs
+++ b/aos/configuration.fbs
@@ -57,6 +57,9 @@
   // Type name of the flatbuffer.
   type:string (id: 1);
   // Max frequency in messages/sec of the data published on this channel.
+  // The maximum number of messages that can be sent
+  // in a channel_storage_duration is
+  // frequency * channel_storage_duration (in seconds).
   frequency:int = 100 (id: 2);
   // Max size of the data being published.  (This will hopefully be
   // automatically computed in the future.)
diff --git a/aos/events/event_loop.cc b/aos/events/event_loop.cc
index 67c4472..3679062 100644
--- a/aos/events/event_loop.cc
+++ b/aos/events/event_loop.cc
@@ -26,6 +26,8 @@
       return "RawSender::Error::kOk";
     case RawSender::Error::kMessagesSentTooFast:
       return "RawSender::Error::kMessagesSentTooFast";
+    case RawSender::Error::kInvalidRedzone:
+      return "RawSender::Error::kInvalidRedzone";
   }
   LOG(FATAL) << "Unknown error given with code " << static_cast<int>(err);
 }
@@ -372,10 +374,21 @@
     flatbuffers::Offset<timing::Statistic> size_offset =
         timing::CreateStatistic(fbb);
 
+    std::vector<flatbuffers::Offset<timing::SendErrorCount>>
+        error_count_offsets;
+    for (size_t ii = 0; ii < internal::RawSenderTiming::kNumErrors; ++ii) {
+      error_count_offsets.push_back(timing::CreateSendErrorCount(
+          fbb, timing::EnumValuesSendError()[ii], 0));
+    }
+    const flatbuffers::Offset<
+        flatbuffers::Vector<flatbuffers::Offset<timing::SendErrorCount>>>
+        error_counts_offset = fbb.CreateVector(error_count_offsets);
+
     timing::Sender::Builder sender_builder(fbb);
 
     sender_builder.add_channel_index(sender->timing_.channel_index);
     sender_builder.add_size(size_offset);
+    sender_builder.add_error_counts(error_counts_offset);
     sender_builder.add_count(0);
     sender_offsets.emplace_back(sender_builder.Finish());
   }
diff --git a/aos/events/event_loop.fbs b/aos/events/event_loop.fbs
index 051f575..c0aaf19 100644
--- a/aos/events/event_loop.fbs
+++ b/aos/events/event_loop.fbs
@@ -2,6 +2,21 @@
 
 namespace aos.timing;
 
+// Enum indicating why a message failed to send.
+enum SendError : byte {
+  // Messages were sent faster than allowed on a given channel.
+  MESSAGE_SENT_TOO_FAST = 0,
+  // The redzone for a message was invalid, implying some form of memory
+  // corruption.
+  INVALID_REDZONE = 1,
+}
+
+// Table used to track how many times a given error occurred.
+table SendErrorCount {
+  error:SendError (id: 0);
+  count:uint (id: 1);
+}
+
 // Holds statistics for a time or size sample.
 table Statistic {
   average:float = nan (id: 0);
@@ -18,6 +33,11 @@
   count:uint (id: 1);
   // Statistics on the size of messages published.
   size:Statistic (id: 2);
+  // Counts of how often different errors occurred. There
+  // should be an entry for all possible errors, even if no errors occurred
+  // since the last timing report. The absence of an entry implies that the
+  // error in question was not supported when the log was generated.
+  error_counts:[SendErrorCount] (id: 4);
 
   // Channel for this sender.  Not filled out by default.
   channel:Channel (id: 3);
diff --git a/aos/events/event_loop.h b/aos/events/event_loop.h
index e810e3f..c2498b3 100644
--- a/aos/events/event_loop.h
+++ b/aos/events/event_loop.h
@@ -139,13 +139,16 @@
  public:
   using SharedSpan = std::shared_ptr<const absl::Span<const uint8_t>>;
 
-  enum class [[nodiscard]] Error{
+  enum class [[nodiscard]] Error {
       // Represents success and no error
       kOk,
 
       // Error for messages on channels being sent faster than their
       // frequency and channel storage duration allow
-      kMessagesSentTooFast};
+      kMessagesSentTooFast,
+      // Access to Redzone was attempted in Sender Queue
+      kInvalidRedzone
+  };
 
   RawSender(EventLoop *event_loop, const Channel *channel);
   RawSender(const RawSender &) = delete;
diff --git a/aos/events/event_loop_param_test.cc b/aos/events/event_loop_param_test.cc
index fca25d4..c8ceeb5 100644
--- a/aos/events/event_loop_param_test.cc
+++ b/aos/events/event_loop_param_test.cc
@@ -4,6 +4,7 @@
 #include <unordered_map>
 #include <unordered_set>
 
+#include "aos/events/test_message_generated.h"
 #include "aos/flatbuffer_merge.h"
 #include "aos/logging/log_message_generated.h"
 #include "aos/logging/logging.h"
@@ -1815,13 +1816,26 @@
 
   auto sender = loop1->MakeSender<TestMessage>("/test");
 
+  // Sanity check channel frequencies to ensure that we've designed the test
+  // correctly.
+  ASSERT_EQ(800, sender.channel()->frequency());
+  ASSERT_EQ(2000000000, loop1->configuration()->channel_storage_duration());
+  constexpr int kMaxAllowedMessages = 800 * 2;
+  constexpr int kSendMessages = kMaxAllowedMessages * 2;
+  constexpr int kDroppedMessages = kSendMessages - kMaxAllowedMessages;
+
   // Add a timer to actually quit.
   auto test_timer = loop1->AddTimer([&sender]() {
-    for (int i = 0; i < 10; ++i) {
+    for (int i = 0; i < kSendMessages; ++i) {
       aos::Sender<TestMessage>::Builder msg = sender.MakeBuilder();
       TestMessage::Builder builder = msg.MakeBuilder<TestMessage>();
       builder.add_value(200 + i);
-      msg.CheckOk(msg.Send(builder.Finish()));
+      if (i < kMaxAllowedMessages) {
+        msg.CheckOk(msg.Send(builder.Finish()));
+      } else {
+        EXPECT_EQ(RawSender::Error::kMessagesSentTooFast,
+                  msg.Send(builder.Finish()));
+      }
     }
   });
 
@@ -1861,7 +1875,27 @@
             ->name()
             ->string_view(),
         "/test");
-    EXPECT_EQ(primary_report.message().senders()->Get(0)->count(), 10);
+    EXPECT_EQ(primary_report.message().senders()->Get(0)->count(),
+              kMaxAllowedMessages);
+    ASSERT_TRUE(primary_report.message().senders()->Get(0)->has_error_counts());
+    ASSERT_EQ(
+        primary_report.message().senders()->Get(0)->error_counts()->size(), 2u);
+    EXPECT_EQ(
+        primary_report.message()
+            .senders()
+            ->Get(0)
+            ->error_counts()
+            ->Get(static_cast<size_t>(timing::SendError::MESSAGE_SENT_TOO_FAST))
+            ->count(),
+        kDroppedMessages)
+        << aos::FlatbufferToJson(primary_report);
+    EXPECT_EQ(primary_report.message()
+                  .senders()
+                  ->Get(0)
+                  ->error_counts()
+                  ->Get(static_cast<size_t>(timing::SendError::INVALID_REDZONE))
+                  ->count(),
+              0);
 
     // Confirm that the timing primary_report sender looks sane.
     EXPECT_EQ(
@@ -2567,5 +2601,148 @@
                "May only send the buffer detached from this Sender");
 }
 
+int TestChannelFrequency(EventLoop *event_loop) {
+  return event_loop->GetChannel<TestMessage>("/test")->frequency();
+}
+
+int TestChannelQueueSize(EventLoop *event_loop) {
+  const int frequency = TestChannelFrequency(event_loop);
+  const auto channel_storage_duration = std::chrono::nanoseconds(
+      event_loop->configuration()->channel_storage_duration());
+  const int queue_size =
+      frequency * std::chrono::duration_cast<std::chrono::duration<double>>(
+                      channel_storage_duration)
+                      .count();
+
+  return queue_size;
+}
+
+RawSender::Error SendTestMessage(aos::Sender<TestMessage> &sender) {
+  aos::Sender<TestMessage>::Builder builder = sender.MakeBuilder();
+  TestMessage::Builder test_message_builder =
+      builder.MakeBuilder<TestMessage>();
+  test_message_builder.add_value(0);
+  return builder.Send(test_message_builder.Finish());
+}
+
+// Test that sending messages too fast returns
+// RawSender::Error::kMessagesSentTooFast.
+TEST_P(AbstractEventLoopTest, SendingMessagesTooFast) {
+  auto event_loop = MakePrimary();
+
+  auto sender = event_loop->MakeSender<TestMessage>("/test");
+
+  // Send one message in the beginning, then wait until the
+  // channel_storage_duration is almost done and start sending messages rapidly,
+  // having some come in the next chanel_storage_duration. The queue_size is
+  // 1600, so the 1601st message will be the last valid one (the initial message
+  // having being sent more than a channel_storage_duration ago), and trying to
+  // send the 1602nd message should return
+  // RawSender::Error::kMessagesSentTooFast.
+  EXPECT_EQ(SendTestMessage(sender), RawSender::Error::kOk);
+  int msgs_sent = 1;
+  const int queue_size = TestChannelQueueSize(event_loop.get());
+
+  const auto timer = event_loop->AddTimer([&]() {
+    const bool done = (msgs_sent == queue_size + 1);
+    ASSERT_EQ(
+        SendTestMessage(sender),
+        done ? RawSender::Error::kMessagesSentTooFast : RawSender::Error::kOk);
+    msgs_sent++;
+    if (done) {
+      Exit();
+    }
+  });
+
+  const auto kRepeatOffset = std::chrono::milliseconds(1);
+  const auto base_offset =
+      std::chrono::nanoseconds(
+          event_loop->configuration()->channel_storage_duration()) -
+      (kRepeatOffset * (queue_size / 2));
+  event_loop->OnRun([&event_loop, &timer, &base_offset, &kRepeatOffset]() {
+    timer->Setup(event_loop->monotonic_now() + base_offset, kRepeatOffset);
+  });
+
+  Run();
+}
+
+// Tests that we are able to send messages successfully after sending messages
+// too fast and waiting while continuously attempting to send messages.
+// Also tests that SendFailureCounter is working correctly in this
+// situation
+TEST_P(AbstractEventLoopTest, SendingAfterSendingTooFast) {
+  auto event_loop = MakePrimary();
+
+  auto sender = event_loop->MakeSender<TestMessage>("/test");
+
+  // We are sending messages at 1 kHz, so we will be sending too fast after
+  // queue_size (1600) ms. After this, keep sending messages, and exactly a
+  // channel storage duration (2s) after we send the first message we should
+  // be able to successfully send a message.
+
+  const monotonic_clock::duration kInterval = std::chrono::milliseconds(1);
+  const monotonic_clock::duration channel_storage_duration =
+      std::chrono::nanoseconds(
+          event_loop->configuration()->channel_storage_duration());
+  const int queue_size = TestChannelQueueSize(event_loop.get());
+
+  int msgs_sent = 0;
+  SendFailureCounter counter;
+  auto start = monotonic_clock::min_time;
+
+  event_loop->AddPhasedLoop(
+      [&](int) {
+        const auto actual_err = SendTestMessage(sender);
+        const bool done_waiting = (start != monotonic_clock::min_time &&
+                                   sender.monotonic_sent_time() >=
+                                       (start + channel_storage_duration));
+        const auto expected_err =
+            (msgs_sent < queue_size || done_waiting
+                 ? RawSender::Error::kOk
+                 : RawSender::Error::kMessagesSentTooFast);
+
+        if (start == monotonic_clock::min_time) {
+          start = sender.monotonic_sent_time();
+        }
+
+        ASSERT_EQ(actual_err, expected_err);
+        counter.Count(actual_err);
+        msgs_sent++;
+
+        EXPECT_EQ(counter.failures(),
+                  msgs_sent <= queue_size
+                      ? 0
+                      : (msgs_sent - queue_size) -
+                            (actual_err == RawSender::Error::kOk ? 1 : 0));
+        EXPECT_EQ(counter.just_failed(), actual_err != RawSender::Error::kOk);
+
+        if (done_waiting) {
+          Exit();
+        }
+      },
+      kInterval);
+  Run();
+}
+
+// Tests that RawSender::Error::kMessagesSentTooFast is returned
+// when messages are sent too fast from senders in different loops
+TEST_P(AbstractEventLoopTest, SendingTooFastWithMultipleLoops) {
+  auto loop1 = MakePrimary();
+  auto loop2 = Make();
+
+  auto sender1 = loop1->MakeSender<TestMessage>("/test");
+  auto sender2 = loop2->MakeSender<TestMessage>("/test");
+
+  // Send queue_size messages split between the senders.
+  const int queue_size = TestChannelQueueSize(loop1.get());
+  for (int i = 0; i < queue_size / 2; i++) {
+    ASSERT_EQ(SendTestMessage(sender1), RawSender::Error::kOk);
+    ASSERT_EQ(SendTestMessage(sender2), RawSender::Error::kOk);
+  }
+
+  // Since queue_size messages have been sent, this should return an error
+  EXPECT_EQ(SendTestMessage(sender2), RawSender::Error::kMessagesSentTooFast);
+}
+
 }  // namespace testing
 }  // namespace aos
diff --git a/aos/events/event_loop_param_test.h b/aos/events/event_loop_param_test.h
index a9d280e..fad8dea 100644
--- a/aos/events/event_loop_param_test.h
+++ b/aos/events/event_loop_param_test.h
@@ -359,6 +359,12 @@
       std::vector<std::reference_wrapper<const Fetcher<TestMessage>>> fetchers,
       std::vector<std::reference_wrapper<const Sender<TestMessage>>> senders);
 
+  // Helper function for testing the sent too fast check using a PhasedLoop with
+  // an interval that sends exactly at the frequency of the channel
+  void TestSentTooFastCheckEdgeCase(
+      const std::function<RawSender::Error(int, int)> expected_err,
+      const bool send_twice_at_end);
+
  private:
   const ::std::unique_ptr<EventLoopTestFactory> factory_;
 
@@ -367,6 +373,13 @@
 
 using AbstractEventLoopDeathTest = AbstractEventLoopTest;
 
+// Returns the frequency of the /test TestMessage channel
+int TestChannelFrequency(EventLoop *event_loop);
+// Returns the queue size of the /test TestMessage channel
+int TestChannelQueueSize(EventLoop *event_loop);
+// Sends a test message with value 0 with the given sender
+RawSender::Error SendTestMessage(aos::Sender<TestMessage> &sender);
+
 }  // namespace testing
 }  // namespace aos
 
diff --git a/aos/events/event_loop_tmpl.h b/aos/events/event_loop_tmpl.h
index 0b08dc0..1382332 100644
--- a/aos/events/event_loop_tmpl.h
+++ b/aos/events/event_loop_tmpl.h
@@ -143,16 +143,26 @@
     uint32_t remote_queue_index, const UUID &uuid) {
   const auto err = DoSend(size, monotonic_remote_time, realtime_remote_time,
                           remote_queue_index, uuid);
-  if (err == RawSender::Error::kOk) {
-    if (timing_.sender) {
-      timing_.size.Add(size);
-      timing_.sender->mutate_count(timing_.sender->count() + 1);
+  switch (err) {
+    case Error::kOk: {
+      if (timing_.sender) {
+        timing_.size.Add(size);
+        timing_.sender->mutate_count(timing_.sender->count() + 1);
+      }
+      ftrace_.FormatMessage(
+          "%.*s: sent internal: event=%" PRId64 " queue=%" PRIu32,
+          static_cast<int>(ftrace_prefix_.size()), ftrace_prefix_.data(),
+          static_cast<int64_t>(
+              monotonic_sent_time().time_since_epoch().count()),
+          sent_queue_index());
+      break;
     }
-    ftrace_.FormatMessage(
-        "%.*s: sent internal: event=%" PRId64 " queue=%" PRIu32,
-        static_cast<int>(ftrace_prefix_.size()), ftrace_prefix_.data(),
-        static_cast<int64_t>(monotonic_sent_time().time_since_epoch().count()),
-        sent_queue_index());
+    case Error::kMessagesSentTooFast:
+      timing_.IncrementError(timing::SendError::MESSAGE_SENT_TOO_FAST);
+      break;
+    case Error::kInvalidRedzone:
+      timing_.IncrementError(timing::SendError::INVALID_REDZONE);
+      break;
   }
   return err;
 }
diff --git a/aos/events/event_scheduler.cc b/aos/events/event_scheduler.cc
index 97e0946..cb0c629 100644
--- a/aos/events/event_scheduler.cc
+++ b/aos/events/event_scheduler.cc
@@ -54,7 +54,7 @@
   auto iter = events_list_.begin();
   const logger::BootTimestamp t =
       FromDistributedClock(scheduler_scheduler_->distributed_now());
-  VLOG(1) << "Got time back " << t;
+  VLOG(2) << "Got time back " << t;
   CHECK_EQ(t.boot, boot_count_);
   CHECK_EQ(t.time, iter->first) << ": Time is wrong on node " << node_index_;
 
@@ -274,7 +274,7 @@
   }
 
   if (min_scheduler) {
-    VLOG(1) << "Oldest event " << min_event_time << " on scheduler "
+    VLOG(2) << "Oldest event " << min_event_time << " on scheduler "
             << min_scheduler->node_index_;
   }
   return std::make_tuple(min_event_time, min_scheduler);
diff --git a/aos/events/logging/boot_timestamp.h b/aos/events/logging/boot_timestamp.h
index dac6533..7eead2e 100644
--- a/aos/events/logging/boot_timestamp.h
+++ b/aos/events/logging/boot_timestamp.h
@@ -22,6 +22,16 @@
   bool operator==(const BootDuration &m2) const {
     return boot == m2.boot && duration == m2.duration;
   }
+  bool operator!=(const BootDuration &m2) const {
+    return boot != m2.boot || duration != m2.duration;
+  }
+
+  static constexpr BootDuration max_time() {
+    return BootDuration{
+        .boot = std::numeric_limits<size_t>::max(),
+        .duration = monotonic_clock::duration(
+            ::std::numeric_limits<monotonic_clock::duration::rep>::max())};
+  }
 };
 
 // Simple class representing which boot and what monotonic time in that boot.
diff --git a/aos/events/logging/log_reader.cc b/aos/events/logging/log_reader.cc
index 4e89a0e..1c3a349 100644
--- a/aos/events/logging/log_reader.cc
+++ b/aos/events/logging/log_reader.cc
@@ -276,6 +276,9 @@
 
           // Otherwise collect this one up as a node to look for a combined
           // channel from.  It is more efficient to compare nodes than channels.
+          LOG(WARNING) << "Failed to find channel "
+                       << finder.SplitChannelName(channel, connection)
+                       << " on node " << aos::FlatbufferToJson(node);
           remote_nodes.insert(connection->name()->string_view());
         }
       }
diff --git a/aos/events/logging/log_reader.h b/aos/events/logging/log_reader.h
index 9bfc90a..196ac53 100644
--- a/aos/events/logging/log_reader.h
+++ b/aos/events/logging/log_reader.h
@@ -406,8 +406,11 @@
 
     EventLoop *MakeEventLoop() {
       CHECK(!event_loop_unique_ptr_);
-      event_loop_unique_ptr_ =
-          node_event_loop_factory_->MakeEventLoop("log_reader");
+      // TODO(james): Enable exclusive senders on LogReader to allow us to
+      // ensure we are remapping channels correctly.
+      event_loop_unique_ptr_ = node_event_loop_factory_->MakeEventLoop(
+          "log_reader", {NodeEventLoopFactory::CheckSentTooFast::kNo,
+                         NodeEventLoopFactory::ExclusiveSenders::kNo});
       return event_loop_unique_ptr_.get();
     }
 
diff --git a/aos/events/logging/logger_test.cc b/aos/events/logging/logger_test.cc
index e9f44b2..6d828c9 100644
--- a/aos/events/logging/logger_test.cc
+++ b/aos/events/logging/logger_test.cc
@@ -416,6 +416,83 @@
   }
 }
 
+// Tests that we can read a logfile that has channels which were sent too fast.
+TEST(SingleNodeLoggerNoFixtureTest, ReadTooFast) {
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config =
+      aos::configuration::ReadConfig(
+          ArtifactPath("aos/events/pingpong_config.json"));
+  SimulatedEventLoopFactory event_loop_factory(&config.message());
+  const ::std::string tmpdir = aos::testing::TestTmpDir();
+  const ::std::string base_name = tmpdir + "/logfile";
+  const ::std::string config_file =
+      absl::StrCat(base_name, kSingleConfigSha256, ".bfbs");
+  const ::std::string logfile = base_name + ".part0.bfbs";
+  // Remove the log file.
+  unlink(config_file.c_str());
+  unlink(logfile.c_str());
+
+  LOG(INFO) << "Logging data to " << logfile;
+
+  int sent_messages = 0;
+
+  {
+    std::unique_ptr<EventLoop> logger_event_loop =
+        event_loop_factory.MakeEventLoop("logger");
+
+    std::unique_ptr<EventLoop> ping_spammer_event_loop =
+        event_loop_factory.GetNodeEventLoopFactory(nullptr)->MakeEventLoop(
+            "ping_spammer", {NodeEventLoopFactory::CheckSentTooFast::kNo,
+                             NodeEventLoopFactory::ExclusiveSenders::kNo});
+    aos::Sender<examples::Ping> ping_sender =
+        ping_spammer_event_loop->MakeSender<examples::Ping>("/test");
+
+    aos::TimerHandler *timer_handler =
+        ping_spammer_event_loop->AddTimer([&ping_sender, &sent_messages]() {
+          aos::Sender<examples::Ping>::Builder builder =
+              ping_sender.MakeBuilder();
+          examples::Ping::Builder ping_builder =
+              builder.MakeBuilder<examples::Ping>();
+          CHECK_EQ(builder.Send(ping_builder.Finish()), RawSender::Error::kOk);
+          ++sent_messages;
+        });
+
+    constexpr std::chrono::microseconds kSendPeriod{10};
+    const int max_legal_messages =
+        ping_sender.channel()->frequency() *
+        event_loop_factory.configuration()->channel_storage_duration() /
+        1000000000;
+
+    ping_spammer_event_loop->OnRun(
+        [&ping_spammer_event_loop, kSendPeriod, timer_handler]() {
+          timer_handler->Setup(
+              ping_spammer_event_loop->monotonic_now() + kSendPeriod / 2,
+              kSendPeriod);
+        });
+
+    Logger logger(logger_event_loop.get());
+    logger.set_separate_config(false);
+    logger.set_polling_period(std::chrono::milliseconds(100));
+    logger.StartLoggingLocalNamerOnRun(base_name);
+
+    event_loop_factory.RunFor(kSendPeriod * max_legal_messages * 2);
+  }
+
+  LogReader reader(logfile);
+
+  reader.Register();
+
+  std::unique_ptr<EventLoop> test_event_loop =
+      reader.event_loop_factory()->MakeEventLoop("log_reader");
+
+  int replay_count = 0;
+
+  test_event_loop->MakeWatcher(
+      "/test", [&replay_count](const examples::Ping &) { ++replay_count; });
+
+  reader.event_loop_factory()->Run();
+  EXPECT_EQ(replay_count, sent_messages);
+}
+
 struct CompressionParams {
   std::string_view extension;
   std::function<std::unique_ptr<DetachedBufferEncoder>()> encoder_factory;
@@ -3393,9 +3470,9 @@
 }
 
 constexpr std::string_view kCombinedConfigSha1(
-    "b33e522a2d0d746f5e514c3a9799987d9c79b2cc45c66f0a91c7a879d5248f0e");
+    "ad71114d104afea6cc400f3a968bb69e394681183fd42655d4efcdc8f4cd8911");
 constexpr std::string_view kSplitConfigSha1(
-    "0f36fe738e357c65082ced1b5d8179e70cb9e2ac6638e748279619db523aec1c");
+    "cdd60ecc4423ef2450bf67bed059f2f28f0e8ff6819b94a2194d825a6b15fe91");
 
 INSTANTIATE_TEST_SUITE_P(
     All, MultinodeLoggerTest,
@@ -4067,6 +4144,76 @@
   ConfirmReadable(filenames);
 }
 
+// Tests that we properly handle only one direction ever existing after a
+// reboot.
+TEST(MissingDirectionTest, OneDirectionAfterReboot) {
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config =
+      aos::configuration::ReadConfig(ArtifactPath(
+          "aos/events/logging/multinode_pingpong_split4_config.json"));
+  message_bridge::TestingTimeConverter time_converter(
+      configuration::NodesCount(&config.message()));
+  SimulatedEventLoopFactory event_loop_factory(&config.message());
+  event_loop_factory.SetTimeConverter(&time_converter);
+
+  NodeEventLoopFactory *const pi1 =
+      event_loop_factory.GetNodeEventLoopFactory("pi1");
+  const size_t pi1_index = configuration::GetNodeIndex(
+      event_loop_factory.configuration(), pi1->node());
+  NodeEventLoopFactory *const pi2 =
+      event_loop_factory.GetNodeEventLoopFactory("pi2");
+  const size_t pi2_index = configuration::GetNodeIndex(
+      event_loop_factory.configuration(), pi2->node());
+  std::vector<std::string> filenames;
+
+  {
+    CHECK_EQ(pi1_index, 0u);
+    CHECK_EQ(pi2_index, 1u);
+
+    time_converter.AddNextTimestamp(
+        distributed_clock::epoch(),
+        {BootTimestamp::epoch(), BootTimestamp::epoch()});
+
+    const chrono::nanoseconds reboot_time = chrono::milliseconds(5000);
+    time_converter.AddNextTimestamp(
+        distributed_clock::epoch() + reboot_time,
+        {BootTimestamp{.boot = 1,
+                       .time = monotonic_clock::epoch()},
+         BootTimestamp::epoch() + reboot_time});
+  }
+
+  const std::string kLogfile2_1 =
+      aos::testing::TestTmpDir() + "/multi_logfile2.1/";
+  util::UnlinkRecursive(kLogfile2_1);
+
+
+  pi1->AlwaysStart<Ping>("ping");
+
+  // Pi1 sends to pi2.  Reboot pi1, but don't let pi2 connect to pi1.  This
+  // makes it such that we will only get timestamps from pi1 -> pi2 on the
+  // second boot.
+  {
+    LoggerState pi2_logger = LoggerState::MakeLogger(
+        pi2, &event_loop_factory, SupportedCompressionAlgorithms()[0]);
+
+    event_loop_factory.RunFor(chrono::milliseconds(95));
+
+    pi2_logger.StartLogger(kLogfile2_1);
+
+    event_loop_factory.RunFor(chrono::milliseconds(4000));
+
+    pi2->Disconnect(pi1->node());
+
+    event_loop_factory.RunFor(chrono::milliseconds(1000));
+    pi1->AlwaysStart<Ping>("ping");
+
+    event_loop_factory.RunFor(chrono::milliseconds(5000));
+    pi2_logger.AppendAllFilenames(&filenames);
+  }
+
+  const std::vector<LogFile> sorted_parts = SortParts(filenames);
+  ConfirmReadable(filenames);
+}
+
 }  // namespace testing
 }  // namespace logger
 }  // namespace aos
diff --git a/aos/events/shm_event_loop.cc b/aos/events/shm_event_loop.cc
index ed3d099..9159553 100644
--- a/aos/events/shm_event_loop.cc
+++ b/aos/events/shm_event_loop.cc
@@ -522,7 +522,10 @@
             chrono::ceil<chrono::seconds>(chrono::nanoseconds(
                 event_loop->configuration()->channel_storage_duration()))),
         lockless_queue_sender_(VerifySender(
-            ipc_lib::LocklessQueueSender::Make(lockless_queue_memory_.queue()),
+            ipc_lib::LocklessQueueSender::Make(
+                lockless_queue_memory_.queue(),
+                std::chrono::nanoseconds(
+                    event_loop->configuration()->channel_storage_duration())),
             channel)),
         wake_upper_(lockless_queue_memory_.queue()) {}
 
@@ -557,17 +560,17 @@
     CHECK_LE(length, static_cast<size_t>(channel()->max_size()))
         << ": Sent too big a message on "
         << configuration::CleanedChannelToString(channel());
-    CHECK(lockless_queue_sender_.Send(length, monotonic_remote_time,
-                                      realtime_remote_time, remote_queue_index,
-                                      source_boot_uuid, &monotonic_sent_time_,
-                                      &realtime_sent_time_, &sent_queue_index_))
+    const auto result = lockless_queue_sender_.Send(
+        length, monotonic_remote_time, realtime_remote_time, remote_queue_index,
+        source_boot_uuid, &monotonic_sent_time_, &realtime_sent_time_,
+        &sent_queue_index_);
+    CHECK_NE(result, ipc_lib::LocklessQueueSender::Result::INVALID_REDZONE)
         << ": Somebody wrote outside the buffer of their message on channel "
         << configuration::CleanedChannelToString(channel());
 
     wake_upper_.Wakeup(event_loop()->is_running() ? event_loop()->priority()
                                                   : 0);
-    // TODO(Milind): check for messages sent too fast
-    return Error::kOk;
+    return CheckLocklessQueueResult(result);
   }
 
   Error DoSend(const void *msg, size_t length,
@@ -579,16 +582,19 @@
     CHECK_LE(length, static_cast<size_t>(channel()->max_size()))
         << ": Sent too big a message on "
         << configuration::CleanedChannelToString(channel());
-    CHECK(lockless_queue_sender_.Send(
+    const auto result = lockless_queue_sender_.Send(
         reinterpret_cast<const char *>(msg), length, monotonic_remote_time,
         realtime_remote_time, remote_queue_index, source_boot_uuid,
-        &monotonic_sent_time_, &realtime_sent_time_, &sent_queue_index_))
-        << ": Somebody wrote outside the buffer of their message on channel "
+        &monotonic_sent_time_, &realtime_sent_time_, &sent_queue_index_);
+
+    CHECK_NE(result, ipc_lib::LocklessQueueSender::Result::INVALID_REDZONE)
+        << ": Somebody wrote outside the buffer of their message on "
+           "channel "
         << configuration::CleanedChannelToString(channel());
     wake_upper_.Wakeup(event_loop()->is_running() ? event_loop()->priority()
                                                   : 0);
-    // TODO(austin): Return an error if we send too fast.
-    return RawSender::Error::kOk;
+
+    return CheckLocklessQueueResult(result);
   }
 
   absl::Span<char> GetSharedMemory() const {
@@ -605,6 +611,20 @@
     return static_cast<const ShmEventLoop *>(event_loop());
   }
 
+  RawSender::Error CheckLocklessQueueResult(
+      const ipc_lib::LocklessQueueSender::Result &result) {
+    switch (result) {
+      case ipc_lib::LocklessQueueSender::Result::GOOD:
+        return Error::kOk;
+      case ipc_lib::LocklessQueueSender::Result::MESSAGES_SENT_TOO_FAST:
+        return Error::kMessagesSentTooFast;
+      case ipc_lib::LocklessQueueSender::Result::INVALID_REDZONE:
+        return Error::kInvalidRedzone;
+    }
+    LOG(FATAL) << "Unknown lockless queue sender result"
+               << static_cast<int>(result);
+  }
+
   MMappedQueue lockless_queue_memory_;
   ipc_lib::LocklessQueueSender lockless_queue_sender_;
   ipc_lib::LocklessQueueWakeUpper wake_upper_;
diff --git a/aos/events/shm_event_loop_test.cc b/aos/events/shm_event_loop_test.cc
index 01ca92b..f4107b0 100644
--- a/aos/events/shm_event_loop_test.cc
+++ b/aos/events/shm_event_loop_test.cc
@@ -116,6 +116,59 @@
 
   ShmEventLoopTestFactory *factory() { return &factory_; }
 
+  // Helper functions for testing when a fetcher cannot fetch the next message
+  // because it was overwritten
+  void TestNextMessageNotAvailable(const bool skip_timing_report) {
+    auto loop1 = factory()->MakePrimary("loop1");
+    if (skip_timing_report) {
+      loop1->SkipTimingReport();
+    }
+    auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
+    auto loop2 = factory()->Make("loop2");
+    auto sender = loop2->MakeSender<TestMessage>("/test");
+    bool ran = false;
+    loop1->AddPhasedLoop(
+        [&sender](int) {
+          auto builder = sender.MakeBuilder();
+          TestMessage::Builder test_builder(*builder.fbb());
+          test_builder.add_value(0);
+          builder.CheckOk(builder.Send(test_builder.Finish()));
+        },
+        std::chrono::milliseconds(2));
+    loop1
+        ->AddTimer([this, &fetcher, &ran]() {
+          EXPECT_DEATH(fetcher.FetchNext(),
+                       "The next message is no longer "
+                       "available.*\"/test\".*\"aos\\.TestMessage\"");
+          factory()->Exit();
+          ran = true;
+        })
+        ->Setup(loop1->monotonic_now() + std::chrono::seconds(4));
+    factory()->Run();
+    EXPECT_TRUE(ran);
+  }
+  void TestNextMessageNotAvailableNoRun(const bool skip_timing_report) {
+    auto loop1 = factory()->MakePrimary("loop1");
+    if (skip_timing_report) {
+      loop1->SkipTimingReport();
+    }
+    auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
+    auto loop2 = factory()->Make("loop2");
+    auto sender = loop2->MakeSender<TestMessage>("/test");
+    time::PhasedLoop phased_loop(std::chrono::milliseconds(2),
+                                 loop2->monotonic_now());
+    for (int i = 0; i < 2000; ++i) {
+      auto builder = sender.MakeBuilder();
+      TestMessage::Builder test_builder(*builder.fbb());
+      test_builder.add_value(0);
+      builder.CheckOk(builder.Send(test_builder.Finish()));
+      phased_loop.SleepUntilNext();
+    }
+    EXPECT_DEATH(fetcher.FetchNext(),
+                 "The next message is no longer "
+                 "available.*\"/test\".*\"aos\\.TestMessage\"");
+  }
+
  private:
   ShmEventLoopTestFactory factory_;
 };
@@ -351,89 +404,25 @@
 // Tests that the next message not being available prints a helpful error in the
 // normal case.
 TEST_P(ShmEventLoopDeathTest, NextMessageNotAvailable) {
-  auto loop1 = factory()->MakePrimary("loop1");
-  auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
-  auto loop2 = factory()->Make("loop2");
-  auto sender = loop2->MakeSender<TestMessage>("/test");
-  bool ran = false;
-  loop1->OnRun([this, &sender, &fetcher, &ran]() {
-    for (int i = 0; i < 2000; ++i) {
-      auto builder = sender.MakeBuilder();
-      TestMessage::Builder test_builder(*builder.fbb());
-      test_builder.add_value(0);
-      builder.CheckOk(builder.Send(test_builder.Finish()));
-    }
-    EXPECT_DEATH(fetcher.FetchNext(),
-                 "The next message is no longer "
-                 "available.*\"/test\".*\"aos\\.TestMessage\"");
-    factory()->Exit();
-    ran = true;
-  });
-  factory()->Run();
-  EXPECT_TRUE(ran);
+  TestNextMessageNotAvailable(false);
 }
 
 // Tests that the next message not being available prints a helpful error with
 // timing reports disabled.
 TEST_P(ShmEventLoopDeathTest, NextMessageNotAvailableNoTimingReports) {
-  auto loop1 = factory()->MakePrimary("loop1");
-  loop1->SkipTimingReport();
-  auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
-  auto loop2 = factory()->Make("loop2");
-  auto sender = loop2->MakeSender<TestMessage>("/test");
-  bool ran = false;
-  loop1->OnRun([this, &sender, &fetcher, &ran]() {
-    for (int i = 0; i < 2000; ++i) {
-      auto builder = sender.MakeBuilder();
-      TestMessage::Builder test_builder(*builder.fbb());
-      test_builder.add_value(0);
-      builder.CheckOk(builder.Send(test_builder.Finish()));
-    }
-    EXPECT_DEATH(fetcher.FetchNext(),
-                 "The next message is no longer "
-                 "available.*\"/test\".*\"aos\\.TestMessage\"");
-    factory()->Exit();
-    ran = true;
-  });
-  factory()->Run();
-  EXPECT_TRUE(ran);
+  TestNextMessageNotAvailable(true);
 }
 
 // Tests that the next message not being available prints a helpful error even
 // when Run is never called.
 TEST_P(ShmEventLoopDeathTest, NextMessageNotAvailableNoRun) {
-  auto loop1 = factory()->MakePrimary("loop1");
-  auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
-  auto loop2 = factory()->Make("loop2");
-  auto sender = loop2->MakeSender<TestMessage>("/test");
-  for (int i = 0; i < 2000; ++i) {
-    auto builder = sender.MakeBuilder();
-    TestMessage::Builder test_builder(*builder.fbb());
-    test_builder.add_value(0);
-    builder.CheckOk(builder.Send(test_builder.Finish()));
-  }
-  EXPECT_DEATH(fetcher.FetchNext(),
-               "The next message is no longer "
-               "available.*\"/test\".*\"aos\\.TestMessage\"");
+  TestNextMessageNotAvailableNoRun(false);
 }
 
 // Tests that the next message not being available prints a helpful error even
 // when Run is never called without timing reports.
 TEST_P(ShmEventLoopDeathTest, NextMessageNotAvailableNoRunNoTimingReports) {
-  auto loop1 = factory()->MakePrimary("loop1");
-  loop1->SkipTimingReport();
-  auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
-  auto loop2 = factory()->Make("loop2");
-  auto sender = loop2->MakeSender<TestMessage>("/test");
-  for (int i = 0; i < 2000; ++i) {
-    auto builder = sender.MakeBuilder();
-    TestMessage::Builder test_builder(*builder.fbb());
-    test_builder.add_value(0);
-    builder.CheckOk(builder.Send(test_builder.Finish()));
-  }
-  EXPECT_DEATH(fetcher.FetchNext(),
-               "The next message is no longer "
-               "available.*\"/test\".*\"aos\\.TestMessage\"");
+  TestNextMessageNotAvailableNoRun(true);
 }
 
 // TODO(austin): Test that missing a deadline with a timer recovers as expected.
diff --git a/aos/events/simulated_event_loop.cc b/aos/events/simulated_event_loop.cc
index a1ef95d..4671f12 100644
--- a/aos/events/simulated_event_loop.cc
+++ b/aos/events/simulated_event_loop.cc
@@ -21,6 +21,10 @@
 class SimulatedFetcher;
 class SimulatedChannel;
 
+using CheckSentTooFast = NodeEventLoopFactory::CheckSentTooFast;
+using ExclusiveSenders = NodeEventLoopFactory::ExclusiveSenders;
+using EventLoopOptions = NodeEventLoopFactory::EventLoopOptions;
+
 namespace {
 
 std::string NodeName(const Node *node) {
@@ -151,10 +155,12 @@
 class SimulatedChannel {
  public:
   explicit SimulatedChannel(const Channel *channel,
-                            std::chrono::nanoseconds channel_storage_duration)
+                            std::chrono::nanoseconds channel_storage_duration,
+                            const EventScheduler *scheduler)
       : channel_(channel),
         channel_storage_duration_(channel_storage_duration),
-        next_queue_index_(ipc_lib::QueueIndex::Zero(number_buffers())) {
+        next_queue_index_(ipc_lib::QueueIndex::Zero(number_buffers())),
+        scheduler_(scheduler) {
     available_buffer_indices_.resize(number_buffers());
     for (int i = 0; i < number_buffers(); ++i) {
       available_buffer_indices_[i] = i;
@@ -229,7 +235,8 @@
 
   // Sends the message to all the connected receivers and fetchers.  Returns the
   // sent queue index, or std::nullopt if messages were sent too fast.
-  std::optional<uint32_t> Send(std::shared_ptr<SimulatedMessage> message);
+  std::optional<uint32_t> Send(std::shared_ptr<SimulatedMessage> message,
+                               CheckSentTooFast check_sent_too_fast);
 
   // Unregisters a fetcher.
   void UnregisterFetcher(SimulatedFetcher *fetcher);
@@ -257,6 +264,9 @@
   void CountSenderDestroyed() {
     --sender_count_;
     CHECK_GE(sender_count_, 0);
+    if (sender_count_ == 0) {
+      allow_new_senders_ = true;
+    }
   }
 
  private:
@@ -294,8 +304,16 @@
   ipc_lib::QueueIndex next_queue_index_;
 
   int sender_count_ = 0;
+  // Used to track when an exclusive sender has been created (e.g., for log
+  // replay) and we want to prevent new senders from being accidentally created.
+  bool allow_new_senders_ = true;
 
   std::vector<uint16_t> available_buffer_indices_;
+
+  const EventScheduler *scheduler_;
+
+  // Queue of all the message send times in the last channel_storage_duration_
+  std::queue<monotonic_clock::time_point> last_times_;
 };
 
 namespace {
@@ -524,7 +542,7 @@
           *channels,
       const Configuration *configuration,
       std::vector<SimulatedEventLoop *> *event_loops_, const Node *node,
-      pid_t tid)
+      pid_t tid, EventLoopOptions options)
       : EventLoop(CHECK_NOTNULL(configuration)),
         scheduler_(scheduler),
         node_event_loop_factory_(node_event_loop_factory),
@@ -532,7 +550,8 @@
         event_loops_(event_loops_),
         node_(node),
         tid_(tid),
-        startup_tracker_(std::make_shared<StartupTracker>()) {
+        startup_tracker_(std::make_shared<StartupTracker>()),
+        options_(options) {
     startup_tracker_->loop = this;
     scheduler_->ScheduleOnStartup([startup_tracker = startup_tracker_]() {
       if (startup_tracker->loop) {
@@ -668,6 +687,8 @@
     return node_event_loop_factory_->boot_uuid();
   }
 
+  const EventLoopOptions &options() const { return options_; }
+
  private:
   friend class SimulatedTimerHandler;
   friend class SimulatedPhasedLoopHandler;
@@ -716,6 +737,8 @@
   bool has_run_ = false;
 
   std::shared_ptr<StartupTracker> startup_tracker_;
+
+  EventLoopOptions options_;
 };
 
 void SimulatedEventLoopFactory::set_send_delay(
@@ -782,14 +805,14 @@
     const Channel *channel) {
   auto it = channels_->find(SimpleChannel(channel));
   if (it == channels_->end()) {
-    it =
-        channels_
-            ->emplace(
-                SimpleChannel(channel),
-                std::unique_ptr<SimulatedChannel>(new SimulatedChannel(
-                    channel, std::chrono::nanoseconds(
-                                 configuration()->channel_storage_duration()))))
-            .first;
+    it = channels_
+             ->emplace(SimpleChannel(channel),
+                       std::unique_ptr<SimulatedChannel>(new SimulatedChannel(
+                           channel,
+                           std::chrono::nanoseconds(
+                               configuration()->channel_storage_duration()),
+                           scheduler_)))
+             .first;
   }
   return it->second.get();
 }
@@ -916,6 +939,16 @@
 
 ::std::unique_ptr<RawSender> SimulatedChannel::MakeRawSender(
     SimulatedEventLoop *event_loop) {
+  CHECK(allow_new_senders_)
+      << ": Attempted to create a new sender on exclusive channel "
+      << configuration::StrippedChannelToString(channel_);
+  if (event_loop->options().exclusive_senders == ExclusiveSenders::kYes) {
+    CHECK_EQ(0, sender_count_)
+        << ": Attempted to add an exclusive sender on a channel with existing "
+           "senders: "
+        << configuration::StrippedChannelToString(channel_);
+    allow_new_senders_ = false;
+  }
   return ::std::unique_ptr<RawSender>(new SimulatedSender(this, event_loop));
 }
 
@@ -929,8 +962,23 @@
 }
 
 std::optional<uint32_t> SimulatedChannel::Send(
-    std::shared_ptr<SimulatedMessage> message) {
-  std::optional<uint32_t> queue_index = {next_queue_index_.index()};
+    std::shared_ptr<SimulatedMessage> message, CheckSentTooFast check_sent_too_fast) {
+  const auto now = scheduler_->monotonic_now();
+  // Remove times that are greater than or equal to a channel_storage_duration_
+  // ago
+  while (!last_times_.empty() &&
+         (now - last_times_.front() >= channel_storage_duration_)) {
+    last_times_.pop();
+  }
+
+  // Check that we are not sending messages too fast
+  if (check_sent_too_fast == CheckSentTooFast::kYes &&
+      static_cast<int>(last_times_.size()) >= queue_size()) {
+    return std::nullopt;
+  }
+
+  const std::optional<uint32_t> queue_index = {next_queue_index_.index()};
+  last_times_.push(now);
 
   message->context.queue_index = *queue_index;
   // Points to the actual data depending on the size set in context. Data may
@@ -1004,7 +1052,7 @@
   message_->context.size = length;
 
   const std::optional<uint32_t> optional_queue_index =
-      simulated_channel_->Send(message_);
+      simulated_channel_->Send(message_, simulated_event_loop_->options().check_sent_too_fast);
 
   // Check that we are not sending messages too fast
   if (!optional_queue_index) {
@@ -1441,7 +1489,7 @@
 }
 
 ::std::unique_ptr<EventLoop> NodeEventLoopFactory::MakeEventLoop(
-    std::string_view name) {
+    std::string_view name, EventLoopOptions options) {
   CHECK(!scheduler_.is_running() || !started_)
       << ": Can't create an event loop while running";
 
@@ -1449,7 +1497,7 @@
   ++tid_;
   ::std::unique_ptr<SimulatedEventLoop> result(new SimulatedEventLoop(
       &scheduler_, this, &channels_, factory_->configuration(), &event_loops_,
-      node_, tid));
+      node_, tid, options));
   result->set_name(name);
   result->set_send_delay(factory_->send_delay());
   if (skip_timing_report_) {
diff --git a/aos/events/simulated_event_loop.h b/aos/events/simulated_event_loop.h
index 9a447e9..234afa0 100644
--- a/aos/events/simulated_event_loop.h
+++ b/aos/events/simulated_event_loop.h
@@ -154,7 +154,26 @@
  public:
   ~NodeEventLoopFactory();
 
-  std::unique_ptr<EventLoop> MakeEventLoop(std::string_view name);
+  // Whether a given event loop should have its senders checked for messages
+  // being sent too fast. Should only be used by the LogReader or other highly
+  // specialized applications that need to be able to bypass normal behaviors.
+  enum class CheckSentTooFast { kNo, kYes };
+  // Whether the created EventLoop should be the only one allowed to send on all
+  // of its channels. Mostly useful for the LogReader, to allow us to confirm
+  // whether the LogReader is conflicting with the output of any applications
+  // being run in replay.
+  enum class ExclusiveSenders { kNo, kYes };
+  struct EventLoopOptions {
+    CheckSentTooFast check_sent_too_fast;
+    ExclusiveSenders exclusive_senders;
+  };
+
+  // Takes the name for the event loop and a struct of options for selecting
+  // what checks to run for the event loop in question.
+  std::unique_ptr<EventLoop> MakeEventLoop(
+      std::string_view name,
+      EventLoopOptions options = EventLoopOptions{CheckSentTooFast::kYes,
+                                                  ExclusiveSenders::kNo});
 
   // Returns the node that this factory is running as, or nullptr if this is a
   // single node setup.
diff --git a/aos/events/simulated_event_loop_test.cc b/aos/events/simulated_event_loop_test.cc
index 09202ff..4b155ce 100644
--- a/aos/events/simulated_event_loop_test.cc
+++ b/aos/events/simulated_event_loop_test.cc
@@ -1,6 +1,7 @@
 #include "aos/events/simulated_event_loop.h"
 
 #include <chrono>
+#include <functional>
 #include <string_view>
 
 #include "aos/events/event_loop_param_test.h"
@@ -139,13 +140,13 @@
 };
 
 class FunctionEvent : public EventScheduler::Event {
-  public:
-   FunctionEvent(std::function<void()> fn) : fn_(fn) {}
+ public:
+  FunctionEvent(std::function<void()> fn) : fn_(fn) {}
 
-   void Handle() noexcept override { fn_(); }
+  void Handle() noexcept override { fn_(); }
 
-  private:
-   std::function<void()> fn_;
+ private:
+  std::function<void()> fn_;
 };
 
 // Test that creating an event and running the scheduler runs the event.
@@ -204,14 +205,6 @@
   EXPECT_EQ(counter, 1);
 }
 
-void SendTestMessage(aos::Sender<TestMessage> *sender, int value) {
-  aos::Sender<TestMessage>::Builder builder = sender->MakeBuilder();
-  TestMessage::Builder test_message_builder =
-      builder.MakeBuilder<TestMessage>();
-  test_message_builder.add_value(value);
-  ASSERT_EQ(builder.Send(test_message_builder.Finish()), RawSender::Error::kOk);
-}
-
 // Test that sending a message after running gets properly notified.
 TEST(SimulatedEventLoopTest, SendAfterRunFor) {
   SimulatedEventLoopTestFactory factory;
@@ -223,7 +216,7 @@
       simulated_event_loop_factory.MakeEventLoop("ping");
   aos::Sender<TestMessage> test_message_sender =
       ping_event_loop->MakeSender<TestMessage>("/test");
-  SendTestMessage(&test_message_sender, 1);
+  ASSERT_EQ(SendTestMessage(test_message_sender), RawSender::Error::kOk);
 
   std::unique_ptr<EventLoop> pong1_event_loop =
       simulated_event_loop_factory.MakeEventLoop("pong");
@@ -243,7 +236,7 @@
 
   // Pauses in the middle don't count though, so this should be counted.
   // But, the fresh watcher shouldn't pick it up yet.
-  SendTestMessage(&test_message_sender, 2);
+  ASSERT_EQ(SendTestMessage(test_message_sender), RawSender::Error::kOk);
 
   EXPECT_EQ(test_message_counter1.count(), 0u);
   EXPECT_EQ(test_message_counter2.count(), 0u);
@@ -253,6 +246,129 @@
   EXPECT_EQ(test_message_counter2.count(), 0u);
 }
 
+// Test that if we configure an event loop to be able to send too fast that we do allow it to do so.
+TEST(SimulatedEventLoopTest, AllowSendTooFast) {
+  SimulatedEventLoopTestFactory factory;
+
+  SimulatedEventLoopFactory simulated_event_loop_factory(
+      factory.configuration());
+
+  // Create two event loops: One will be allowed to send too fast, one won't. We
+  // will then test to ensure that the one that is allowed to send too fast can
+  // indeed send too fast, but that it then makes it so that the second event
+  // loop can no longer send anything because *it* is still limited.
+  ::std::unique_ptr<EventLoop> too_fast_event_loop =
+      simulated_event_loop_factory.GetNodeEventLoopFactory(nullptr)
+          ->MakeEventLoop("too_fast_sender",
+                          {NodeEventLoopFactory::CheckSentTooFast::kNo,
+                           NodeEventLoopFactory::ExclusiveSenders::kNo});
+  aos::Sender<TestMessage> too_fast_message_sender =
+      too_fast_event_loop->MakeSender<TestMessage>("/test");
+
+  ::std::unique_ptr<EventLoop> limited_event_loop =
+      simulated_event_loop_factory.MakeEventLoop("limited_sender");
+  aos::Sender<TestMessage> limited_message_sender =
+      limited_event_loop->MakeSender<TestMessage>("/test");
+
+  const int queue_size = TestChannelQueueSize(too_fast_event_loop.get());
+  for (int ii = 0; ii < queue_size; ++ii) {
+    ASSERT_EQ(SendTestMessage(too_fast_message_sender), RawSender::Error::kOk);
+  }
+  // And now we should start being in the sending-too-fast phase.
+  for (int ii = 0; ii < queue_size; ++ii) {
+    ASSERT_EQ(SendTestMessage(too_fast_message_sender), RawSender::Error::kOk);
+    ASSERT_EQ(SendTestMessage(limited_message_sender), RawSender::Error::kMessagesSentTooFast);
+  }
+}
+
+// Test that if we setup an exclusive sender that it is indeed exclusive.
+TEST(SimulatedEventLoopDeathTest, ExclusiveSenders) {
+  SimulatedEventLoopTestFactory factory;
+
+  SimulatedEventLoopFactory simulated_event_loop_factory(
+      factory.configuration());
+
+  ::std::unique_ptr<EventLoop> exclusive_event_loop =
+      simulated_event_loop_factory.GetNodeEventLoopFactory(nullptr)
+          ->MakeEventLoop("too_fast_sender",
+                          {NodeEventLoopFactory::CheckSentTooFast::kYes,
+                           NodeEventLoopFactory::ExclusiveSenders::kYes});
+  exclusive_event_loop->SkipAosLog();
+  exclusive_event_loop->SkipTimingReport();
+  ::std::unique_ptr<EventLoop> normal_event_loop =
+      simulated_event_loop_factory.MakeEventLoop("limited_sender");
+  // Set things up to have the exclusive sender be destroyed so we can test
+  // recovery.
+  {
+    aos::Sender<TestMessage> exclusive_sender =
+        exclusive_event_loop->MakeSender<TestMessage>("/test");
+
+    EXPECT_DEATH(normal_event_loop->MakeSender<TestMessage>("/test"),
+                 "TestMessage");
+  }
+  // This one should succeed now that the exclusive channel is removed.
+  aos::Sender<TestMessage> normal_sender =
+      normal_event_loop->MakeSender<TestMessage>("/test");
+  EXPECT_DEATH(exclusive_event_loop->MakeSender<TestMessage>("/test"), "TestMessage");
+}
+
+void TestSentTooFastCheckEdgeCase(
+    const std::function<RawSender::Error(int, int)> expected_err,
+    const bool send_twice_at_end) {
+  SimulatedEventLoopTestFactory factory;
+
+  auto event_loop = factory.MakePrimary("primary");
+
+  auto sender = event_loop->MakeSender<TestMessage>("/test");
+
+  const int queue_size = TestChannelQueueSize(event_loop.get());
+  int msgs_sent = 0;
+  event_loop->AddPhasedLoop(
+      [&](int) {
+        EXPECT_EQ(SendTestMessage(sender), expected_err(msgs_sent, queue_size));
+        msgs_sent++;
+
+        // If send_twice_at_end, send the last two messages (message
+        // queue_size and queue_size + 1) in the same iteration, meaning that
+        // we would be sending very slightly too fast. Otherwise, we will send
+        // message queue_size + 1 in the next iteration and we will continue
+        // to be sending exactly at the channel frequency.
+        if (send_twice_at_end && (msgs_sent == queue_size)) {
+          EXPECT_EQ(SendTestMessage(sender),
+                    expected_err(msgs_sent, queue_size));
+          msgs_sent++;
+        }
+
+        if (msgs_sent > queue_size) {
+          factory.Exit();
+        }
+      },
+      std::chrono::duration_cast<std::chrono::nanoseconds>(
+          std::chrono::duration<double>(
+              1.0 / TestChannelFrequency(event_loop.get()))));
+
+  factory.Run();
+}
+
+// Tests that RawSender::Error::kMessagesSentTooFast is not returned
+// when messages are sent at the exact frequency of the channel.
+TEST(SimulatedEventLoopTest, SendingAtExactlyChannelFrequency) {
+  TestSentTooFastCheckEdgeCase([](int, int) { return RawSender::Error::kOk; },
+                               false);
+}
+
+// Tests that RawSender::Error::kMessagesSentTooFast is returned
+// when sending exactly one more message than allowed in a channel storage
+// duration.
+TEST(SimulatedEventLoopTest, SendingSlightlyTooFast) {
+  TestSentTooFastCheckEdgeCase(
+      [](const int msgs_sent, const int queue_size) {
+        return (msgs_sent == queue_size ? RawSender::Error::kMessagesSentTooFast
+                                        : RawSender::Error::kOk);
+      },
+      true);
+}
+
 // Test that creating an event loop while running dies.
 TEST(SimulatedEventLoopDeathTest, MakeEventLoopWhileRunning) {
   SimulatedEventLoopTestFactory factory;
@@ -1338,7 +1454,6 @@
   EXPECT_EQ(ConnectedCount(pi3_client_statistics_fetcher.get(), "pi1"), 2u)
       << " : " << aos::FlatbufferToJson(pi3_client_statistics_fetcher.get());
 
-
   EXPECT_EQ(pi1_pong_counter.count(), 601u);
   EXPECT_EQ(pi2_pong_counter.count(), 601u);
 
@@ -1707,18 +1822,17 @@
       });
 
   // Confirm that reboot changes the UUID.
-  pi2->OnShutdown(
-      [&expected_boot_uuid, &boot_number, &expected_connection_time, pi1, pi2,
-       pi2_boot1]() {
-        expected_boot_uuid = pi2_boot1;
-        ++boot_number;
-        LOG(INFO) << "OnShutdown triggered for pi2";
-        pi2->OnStartup(
-            [&expected_boot_uuid, &expected_connection_time, pi1, pi2]() {
-              EXPECT_EQ(expected_boot_uuid, pi2->boot_uuid());
-              expected_connection_time = pi1->monotonic_now();
-            });
-      });
+  pi2->OnShutdown([&expected_boot_uuid, &boot_number, &expected_connection_time,
+                   pi1, pi2, pi2_boot1]() {
+    expected_boot_uuid = pi2_boot1;
+    ++boot_number;
+    LOG(INFO) << "OnShutdown triggered for pi2";
+    pi2->OnStartup(
+        [&expected_boot_uuid, &expected_connection_time, pi1, pi2]() {
+          EXPECT_EQ(expected_boot_uuid, pi2->boot_uuid());
+          expected_connection_time = pi1->monotonic_now();
+        });
+  });
 
   // Let a couple of ServerStatistics messages show up before rebooting.
   factory.RunFor(chrono::milliseconds(2002));
diff --git a/aos/events/simulated_network_bridge.h b/aos/events/simulated_network_bridge.h
index 3a7a4e8..f5b3eae 100644
--- a/aos/events/simulated_network_bridge.h
+++ b/aos/events/simulated_network_bridge.h
@@ -83,7 +83,12 @@
     }
 
     void MakeEventLoop() {
-      SetEventLoop(node_factory_->MakeEventLoop("message_bridge"));
+      // Message bridge isn't the thing that should be catching sent-too-fast,
+      // and may need to be able to forward too-fast messages replayed from old
+      // logfiles.
+      SetEventLoop(node_factory_->MakeEventLoop(
+          "message_bridge", {NodeEventLoopFactory::CheckSentTooFast::kNo,
+                             NodeEventLoopFactory::ExclusiveSenders::kNo}));
     }
 
     void SetEventLoop(std::unique_ptr<aos::EventLoop> loop);
diff --git a/aos/events/timing_statistics.cc b/aos/events/timing_statistics.cc
index 52f2048..fbc49f4 100644
--- a/aos/events/timing_statistics.cc
+++ b/aos/events/timing_statistics.cc
@@ -40,6 +40,19 @@
 
   size.Reset();
   sender->mutate_count(0);
+  for (size_t ii = 0; ii < kNumErrors; ++ii) {
+    sender->mutable_error_counts()->GetMutableObject(ii)->mutate_count(0);
+  }
+}
+
+void RawSenderTiming::IncrementError(timing::SendError error) {
+  if (!sender) {
+    return;
+  }
+  const size_t index = static_cast<size_t>(error);
+  timing::SendErrorCount *counter =
+      sender->mutable_error_counts()->GetMutableObject(index);
+  counter->mutate_count(counter->count() + 1);
 }
 
 void TimerTiming::set_timing_report(timing::Timer *new_timer) {
diff --git a/aos/events/timing_statistics.h b/aos/events/timing_statistics.h
index 4d9a524..e9edff2 100644
--- a/aos/events/timing_statistics.h
+++ b/aos/events/timing_statistics.h
@@ -79,10 +79,24 @@
 
 // Class to hold timing information for a raw sender.
 struct RawSenderTiming {
+  static constexpr size_t kNumErrors =
+      static_cast<int>(timing::SendError::MAX) -
+      static_cast<int>(timing::SendError::MIN) + 1;
+
   RawSenderTiming(int new_channel_index) : channel_index(new_channel_index) {}
 
   void set_timing_report(timing::Sender *sender);
   void ResetTimingReport();
+  void IncrementError(timing::SendError error);
+  // Sanity check that the enum values are such that we can just use the enum
+  // values themselves as array indices without anything weird happening.
+  static_assert(0 == static_cast<int>(timing::SendError::MIN),
+                "Expected error enum values to start at zero.");
+  static_assert(
+      sizeof(std::invoke_result<decltype(timing::EnumValuesSendError)>::type) /
+              sizeof(timing::SendError) ==
+          kNumErrors,
+      "Expected continguous enum values.");
 
   const int channel_index;
   timing::Sender *sender = nullptr;
diff --git a/aos/ipc_lib/BUILD b/aos/ipc_lib/BUILD
index c124fe0..ef6c4f3 100644
--- a/aos/ipc_lib/BUILD
+++ b/aos/ipc_lib/BUILD
@@ -216,6 +216,7 @@
         "//aos/events:epoll",
         "//aos/testing:googletest",
         "//aos/testing:prevent_exit",
+        "//aos/util:phased_loop",
     ],
 )
 
diff --git a/aos/ipc_lib/lockless_queue.cc b/aos/ipc_lib/lockless_queue.cc
index fe86f6c..5f12423 100644
--- a/aos/ipc_lib/lockless_queue.cc
+++ b/aos/ipc_lib/lockless_queue.cc
@@ -4,6 +4,7 @@
 #include <sys/types.h>
 #include <syscall.h>
 #include <unistd.h>
+
 #include <algorithm>
 #include <iomanip>
 #include <iostream>
@@ -503,7 +504,7 @@
 
   bool bad = false;
 
-  for (size_t i = 0; i < redzone.size(); ++i) {
+  for (size_t i = 0; i < redzone.size() && !bad; ++i) {
     if (memcmp(&redzone[i], &redzone_value, 1)) {
       bad = true;
     }
@@ -603,6 +604,7 @@
       Message *const message =
           memory->GetMessage(Index(QueueIndex::Zero(memory->queue_size()), i));
       message->header.queue_index.Invalidate();
+      message->header.monotonic_sent_time = monotonic_clock::min_time;
       FillRedzone(memory, message->PreRedzone(memory->message_data_size()));
       FillRedzone(memory, message->PostRedzone(memory->message_data_size(),
                                                memory->message_size()));
@@ -831,8 +833,16 @@
   return count;
 }
 
-LocklessQueueSender::LocklessQueueSender(LocklessQueueMemory *memory)
-    : memory_(memory) {
+std::ostream &operator<<(std::ostream &os,
+                         const LocklessQueueSender::Result r) {
+  os << static_cast<int>(r);
+  return os;
+}
+
+LocklessQueueSender::LocklessQueueSender(
+    LocklessQueueMemory *memory,
+    monotonic_clock::duration channel_storage_duration)
+    : memory_(memory), channel_storage_duration_(channel_storage_duration) {
   GrabQueueSetupLockOrDie grab_queue_setup_lock(memory_);
 
   // Since we already have the lock, go ahead and try cleaning up.
@@ -877,9 +887,9 @@
 }
 
 std::optional<LocklessQueueSender> LocklessQueueSender::Make(
-    LocklessQueue queue) {
+    LocklessQueue queue, monotonic_clock::duration channel_storage_duration) {
   queue.Initialize();
-  LocklessQueueSender result(queue.memory());
+  LocklessQueueSender result(queue.memory(), channel_storage_duration);
   if (result.sender_index_ != -1) {
     return std::move(result);
   } else {
@@ -904,7 +914,7 @@
   return message->data(memory_->message_data_size());
 }
 
-bool LocklessQueueSender::Send(
+LocklessQueueSender::Result LocklessQueueSender::Send(
     const char *data, size_t length,
     monotonic_clock::time_point monotonic_remote_time,
     realtime_clock::time_point realtime_remote_time,
@@ -921,7 +931,7 @@
               realtime_sent_time, queue_index);
 }
 
-bool LocklessQueueSender::Send(
+LocklessQueueSender::Result LocklessQueueSender::Send(
     size_t length, monotonic_clock::time_point monotonic_remote_time,
     realtime_clock::time_point realtime_remote_time,
     uint32_t remote_queue_index, const UUID &source_boot_uuid,
@@ -936,7 +946,7 @@
   const Index scratch_index = sender->scratch_index.RelaxedLoad();
   Message *const message = memory_->GetMessage(scratch_index);
   if (CheckBothRedzones(memory_, message)) {
-    return false;
+    return Result::INVALID_REDZONE;
   }
 
   // We should have invalidated this when we first got the buffer. Verify that
@@ -995,11 +1005,14 @@
     // This is just a best-effort check to skip reading the clocks if possible.
     // If this fails, then the compare-exchange below definitely would, so we
     // can bail out now.
+    const Message *message_to_replace = memory_->GetMessage(to_replace);
+    bool is_previous_index_valid = false;
     {
       const QueueIndex previous_index =
-          memory_->GetMessage(to_replace)
-              ->header.queue_index.RelaxedLoad(queue_size);
-      if (previous_index != decremented_queue_index && previous_index.valid()) {
+          message_to_replace->header.queue_index.RelaxedLoad(queue_size);
+      is_previous_index_valid = previous_index.valid();
+      if (previous_index != decremented_queue_index &&
+          is_previous_index_valid) {
         // Retry.
         VLOG(3) << "Something fishy happened, queue index doesn't match.  "
                    "Retrying.  Previous index was "
@@ -1011,6 +1024,7 @@
 
     message->header.monotonic_sent_time = ::aos::monotonic_clock::now();
     message->header.realtime_sent_time = ::aos::realtime_clock::now();
+
     if (monotonic_sent_time != nullptr) {
       *monotonic_sent_time = message->header.monotonic_sent_time;
     }
@@ -1021,8 +1035,48 @@
       *queue_index = next_queue_index.index();
     }
 
+    const auto to_replace_monotonic_sent_time =
+        message_to_replace->header.monotonic_sent_time;
+
+    // If we are overwriting a message sent in the last
+    // channel_storage_duration_, that means that we would be sending more than
+    // queue_size messages and would therefore be sending too fast. If the
+    // previous index is not valid then the message hasn't been filled out yet
+    // so we aren't sending too fast. And, if it is not less than the sent time
+    // of the message that we are going to write, someone else beat us and the
+    // compare and exchange below will fail.
+    if (is_previous_index_valid &&
+        (to_replace_monotonic_sent_time <
+         message->header.monotonic_sent_time) &&
+        (message->header.monotonic_sent_time - to_replace_monotonic_sent_time <
+         channel_storage_duration_)) {
+      // There is a possibility that another context beat us to writing out the
+      // message in the queue, but we beat that context to acquiring the sent
+      // time. In this case our sent time is *greater than* the other context's
+      // sent time. Therefore, we can check if we got beat filling out this
+      // message *after* doing the above check to determine if we hit this edge
+      // case. Otherwise, messages are being sent too fast.
+      const QueueIndex previous_index =
+          message_to_replace->header.queue_index.Load(queue_size);
+      if (previous_index != decremented_queue_index && previous_index.valid()) {
+        VLOG(3) << "Got beat during check for messages being sent too fast"
+                   "Retrying.";
+        continue;
+      } else {
+        VLOG(3) << "Messages sent too fast. Returning. Attempted index: "
+                << decremented_queue_index.index()
+                << " message sent time: " << message->header.monotonic_sent_time
+                << "  message to replace sent time: "
+                << to_replace_monotonic_sent_time;
+        // Since we are not using the message obtained from scratch_index
+        // and we are not retrying, we need to invalidate its queue_index.
+        message->header.queue_index.Invalidate();
+        return Result::MESSAGES_SENT_TOO_FAST;
+      }
+    }
+
     // Before we are fully done filling out the message, update the Sender state
-    // with the new index to write.  This re-uses the barrier for the
+    // with the new index to write. This re-uses the barrier for the
     // queue_index store.
     const Index index_to_write(next_queue_index, scratch_index.message_index());
 
@@ -1085,7 +1139,7 @@
   // If anybody is looking at this message (they shouldn't be), then try telling
   // them about it (best-effort).
   memory_->GetMessage(new_scratch)->header.queue_index.RelaxedInvalidate();
-  return true;
+  return Result::GOOD;
 }
 
 int LocklessQueueSender::buffer_index() const {
diff --git a/aos/ipc_lib/lockless_queue.h b/aos/ipc_lib/lockless_queue.h
index d6fb72f..f7a85c3 100644
--- a/aos/ipc_lib/lockless_queue.h
+++ b/aos/ipc_lib/lockless_queue.h
@@ -282,10 +282,19 @@
 // scoped to this object's lifetime.
 class LocklessQueueSender {
  public:
+  // Enum of possible sending errors
+  // Send returns GOOD if the messages was sent successfully, INVALID_REDZONE if
+  // one of a message's redzones has invalid data, or MESSAGES_SENT_TOO_FAST if
+  // more than queue_size messages were going to be sent in a
+  // channel_storage_duration_.
+  enum class Result { GOOD, INVALID_REDZONE, MESSAGES_SENT_TOO_FAST };
+
   LocklessQueueSender(const LocklessQueueSender &) = delete;
   LocklessQueueSender &operator=(const LocklessQueueSender &) = delete;
   LocklessQueueSender(LocklessQueueSender &&other)
-      : memory_(other.memory_), sender_index_(other.sender_index_) {
+      : memory_(other.memory_),
+        sender_index_(other.sender_index_),
+        channel_storage_duration_(other.channel_storage_duration_) {
     other.memory_ = nullptr;
     other.sender_index_ = -1;
   }
@@ -299,7 +308,8 @@
 
   // Creates a sender.  If we couldn't allocate a sender, returns nullopt.
   // TODO(austin): Change the API if we find ourselves with more errors.
-  static std::optional<LocklessQueueSender> Make(LocklessQueue queue);
+  static std::optional<LocklessQueueSender> Make(
+      LocklessQueue queue, monotonic_clock::duration channel_storage_duration);
 
   // Sends a message without copying the data.
   // Copy at most size() bytes of data into the memory pointed to by Data(),
@@ -307,34 +317,43 @@
   // Note: calls to Data() are expensive enough that you should cache it.
   size_t size() const;
   void *Data();
-  bool Send(size_t length, monotonic_clock::time_point monotonic_remote_time,
-            realtime_clock::time_point realtime_remote_time,
-            uint32_t remote_queue_index, const UUID &source_boot_uuid,
-            monotonic_clock::time_point *monotonic_sent_time = nullptr,
-            realtime_clock::time_point *realtime_sent_time = nullptr,
-            uint32_t *queue_index = nullptr);
+  LocklessQueueSender::Result Send(
+      size_t length, monotonic_clock::time_point monotonic_remote_time,
+      realtime_clock::time_point realtime_remote_time,
+      uint32_t remote_queue_index, const UUID &source_boot_uuid,
+      monotonic_clock::time_point *monotonic_sent_time = nullptr,
+      realtime_clock::time_point *realtime_sent_time = nullptr,
+      uint32_t *queue_index = nullptr);
 
   // Sends up to length data.  Does not wakeup the target.
-  bool Send(const char *data, size_t length,
-            monotonic_clock::time_point monotonic_remote_time,
-            realtime_clock::time_point realtime_remote_time,
-            uint32_t remote_queue_index, const UUID &source_boot_uuid,
-            monotonic_clock::time_point *monotonic_sent_time = nullptr,
-            realtime_clock::time_point *realtime_sent_time = nullptr,
-            uint32_t *queue_index = nullptr);
+  LocklessQueueSender::Result Send(
+      const char *data, size_t length,
+      monotonic_clock::time_point monotonic_remote_time,
+      realtime_clock::time_point realtime_remote_time,
+      uint32_t remote_queue_index, const UUID &source_boot_uuid,
+      monotonic_clock::time_point *monotonic_sent_time = nullptr,
+      realtime_clock::time_point *realtime_sent_time = nullptr,
+      uint32_t *queue_index = nullptr);
 
   int buffer_index() const;
 
  private:
-  LocklessQueueSender(LocklessQueueMemory *memory);
+  LocklessQueueSender(LocklessQueueMemory *memory,
+                      monotonic_clock::duration channel_storage_duration);
 
   // Pointer to the backing memory.
   LocklessQueueMemory *memory_ = nullptr;
 
   // Index into the sender list.
   int sender_index_ = -1;
+
+  // Storage duration of the channel used to check if messages were sent too
+  // fast
+  const monotonic_clock::duration channel_storage_duration_;
 };
 
+std::ostream &operator<<(std::ostream &os, const LocklessQueueSender::Result r);
+
 // Pinner for blocks of data.  The resources associated with a pinner are
 // scoped to this object's lifetime.
 class LocklessQueuePinner {
diff --git a/aos/ipc_lib/lockless_queue_death_test.cc b/aos/ipc_lib/lockless_queue_death_test.cc
index 2217811..c5edb9e 100644
--- a/aos/ipc_lib/lockless_queue_death_test.cc
+++ b/aos/ipc_lib/lockless_queue_death_test.cc
@@ -558,6 +558,9 @@
 
 static int kPinnedMessageIndex = 0;
 
+constexpr monotonic_clock::duration kChannelStorageDuration =
+    std::chrono::milliseconds(500);
+
 }  // namespace
 
 // Tests that death during sends is recovered from correctly.
@@ -575,7 +578,7 @@
   config.num_watchers = 2;
   config.num_senders = 2;
   config.num_pinners = 1;
-  config.queue_size = 2;
+  config.queue_size = 10;
   config.message_data_size = 32;
 
   TestShmRobustness(
@@ -596,14 +599,16 @@
             config);
         // Now try to write some messages.  We will get killed a bunch as this
         // tries to happen.
-        LocklessQueueSender sender = LocklessQueueSender::Make(queue).value();
+        LocklessQueueSender sender =
+            LocklessQueueSender::Make(queue, kChannelStorageDuration).value();
         LocklessQueuePinner pinner = LocklessQueuePinner::Make(queue).value();
         for (int i = 0; i < 5; ++i) {
           char data[100];
           size_t s = snprintf(data, sizeof(data), "foobar%d", i + 1);
-          sender.Send(data, s + 1, monotonic_clock::min_time,
-                      realtime_clock::min_time, 0xffffffffl, UUID::Zero(),
-                      nullptr, nullptr, nullptr);
+          ASSERT_EQ(sender.Send(data, s + 1, monotonic_clock::min_time,
+                                realtime_clock::min_time, 0xffffffffl,
+                                UUID::Zero(), nullptr, nullptr, nullptr),
+                    LocklessQueueSender::Result::GOOD);
           // Pin a message, so when we keep writing we will exercise the pinning
           // logic.
           if (i == 1) {
@@ -613,7 +618,8 @@
       },
       [config, tid](void *raw_memory) {
         ::aos::ipc_lib::LocklessQueueMemory *const memory =
-            reinterpret_cast<::aos::ipc_lib::LocklessQueueMemory *>(raw_memory);
+            reinterpret_cast< ::aos::ipc_lib::LocklessQueueMemory *>(
+                raw_memory);
         // Confirm that we can create 2 senders (the number in the queue), and
         // send a message.  And that all the messages in the queue are valid.
         LocklessQueue queue(memory, memory, config);
@@ -639,7 +645,7 @@
         }
 
         // Building and destroying a sender will clean up the queue.
-        LocklessQueueSender::Make(queue).value();
+        LocklessQueueSender::Make(queue, kChannelStorageDuration).value();
 
         if (print) {
           LOG(INFO) << "Cleaned up version:";
@@ -665,19 +671,21 @@
         }
 
         {
-          LocklessQueueSender sender = LocklessQueueSender::Make(queue).value();
+          LocklessQueueSender sender =
+              LocklessQueueSender::Make(queue, kChannelStorageDuration).value();
           {
             // Make a second sender to confirm that the slot was freed.
             // If the sender doesn't get cleaned up, this will fail.
-            LocklessQueueSender::Make(queue).value();
+            LocklessQueueSender::Make(queue, kChannelStorageDuration).value();
           }
 
           // Send a message to make sure that the queue still works.
           char data[100];
           size_t s = snprintf(data, sizeof(data), "foobar%d", 971);
-          sender.Send(data, s + 1, monotonic_clock::min_time,
-                      realtime_clock::min_time, 0xffffffffl, UUID::Zero(),
-                      nullptr, nullptr, nullptr);
+          ASSERT_EQ(sender.Send(data, s + 1, monotonic_clock::min_time,
+                                realtime_clock::min_time, 0xffffffffl,
+                                UUID::Zero(), nullptr, nullptr, nullptr),
+                    LocklessQueueSender::Result::GOOD);
         }
 
         // Now loop through the queue and make sure the number in the snprintf
diff --git a/aos/ipc_lib/lockless_queue_test.cc b/aos/ipc_lib/lockless_queue_test.cc
index 2b9f49c..57dd94b 100644
--- a/aos/ipc_lib/lockless_queue_test.cc
+++ b/aos/ipc_lib/lockless_queue_test.cc
@@ -16,6 +16,7 @@
 #include "aos/ipc_lib/queue_racer.h"
 #include "aos/ipc_lib/signalfd.h"
 #include "aos/realtime.h"
+#include "aos/util/phased_loop.h"
 #include "gflags/gflags.h"
 #include "gtest/gtest.h"
 
@@ -42,6 +43,9 @@
 
 class LocklessQueueTest : public ::testing::Test {
  public:
+  static constexpr monotonic_clock::duration kChannelStorageDuration =
+      std::chrono::milliseconds(500);
+
   LocklessQueueTest() {
     config_.num_watchers = 10;
     config_.num_senders = 100;
@@ -99,8 +103,6 @@
   LocklessQueueConfiguration config_;
 };
 
-typedef LocklessQueueTest LocklessQueueDeathTest;
-
 // Tests that wakeup doesn't do anything if nothing was registered.
 TEST_F(LocklessQueueTest, NoWatcherWakeup) {
   LocklessQueueWakeUpper wake_upper(queue());
@@ -190,9 +192,10 @@
 TEST_F(LocklessQueueTest, TooManySenders) {
   ::std::vector<LocklessQueueSender> senders;
   for (size_t i = 0; i < config_.num_senders; ++i) {
-    senders.emplace_back(LocklessQueueSender::Make(queue()).value());
+    senders.emplace_back(
+        LocklessQueueSender::Make(queue(), kChannelStorageDuration).value());
   }
-  EXPECT_FALSE(LocklessQueueSender::Make(queue()));
+  EXPECT_FALSE(LocklessQueueSender::Make(queue(), kChannelStorageDuration));
 }
 
 // Now, start 2 threads and have them receive the signals.
@@ -226,9 +229,11 @@
 
 // Do a simple send test.
 TEST_F(LocklessQueueTest, Send) {
-  LocklessQueueSender sender = LocklessQueueSender::Make(queue()).value();
+  LocklessQueueSender sender =
+      LocklessQueueSender::Make(queue(), kChannelStorageDuration).value();
   LocklessQueueReader reader(queue());
 
+  time::PhasedLoop loop(std::chrono::microseconds(1), monotonic_clock::now());
   // Send enough messages to wrap.
   for (int i = 0; i < 20000; ++i) {
     // Confirm that the queue index makes sense given the number of sends.
@@ -238,8 +243,10 @@
     // Send a trivial piece of data.
     char data[100];
     size_t s = snprintf(data, sizeof(data), "foobar%d", i);
-    sender.Send(data, s, monotonic_clock::min_time, realtime_clock::min_time,
-                0xffffffffu, UUID::Zero(), nullptr, nullptr, nullptr);
+    EXPECT_EQ(sender.Send(data, s, monotonic_clock::min_time,
+                          realtime_clock::min_time, 0xffffffffu, UUID::Zero(),
+                          nullptr, nullptr, nullptr),
+              LocklessQueueSender::Result::GOOD);
 
     // Confirm that the queue index still makes sense.  This is easier since the
     // empty case has been handled.
@@ -271,6 +278,8 @@
     if (read_result != LocklessQueueReader::Result::GOOD) {
       EXPECT_EQ(read_result, LocklessQueueReader::Result::TOO_OLD);
     }
+
+    loop.SleepUntilNext();
   }
 }
 
@@ -342,7 +351,42 @@
 
 }  // namespace
 
-// Send enough messages to wrap the 32 bit send counter.
+class LocklessQueueTestTooFast : public LocklessQueueTest {
+ public:
+  LocklessQueueTestTooFast() {
+    // Force a scenario where senders get rate limited
+    config_.num_watchers = 1000;
+    config_.num_senders = 100;
+    config_.num_pinners = 5;
+    config_.queue_size = 100;
+    // Exercise the alignment code.  This would throw off alignment.
+    config_.message_data_size = 101;
+
+    // Since our backing store is an array of uint64_t for alignment purposes,
+    // normalize by the size.
+    memory_.resize(LocklessQueueMemorySize(config_) / sizeof(uint64_t));
+
+    Reset();
+  }
+};
+
+// Ensure we always return OK or MESSAGES_SENT_TOO_FAST under an extreme load
+// on the Sender Queue.
+TEST_F(LocklessQueueTestTooFast, MessagesSentTooFast) {
+  PinForTest pin_cpu;
+  uint64_t kNumMessages = 1000000;
+  QueueRacer racer(queue(),
+                   {FLAGS_thread_count,
+                    kNumMessages,
+                    {LocklessQueueSender::Result::GOOD,
+                     LocklessQueueSender::Result::MESSAGES_SENT_TOO_FAST},
+                    std::chrono::milliseconds(500),
+                    false});
+
+  EXPECT_NO_FATAL_FAILURE(racer.RunIteration(false, 0));
+}
+
+// // Send enough messages to wrap the 32 bit send counter.
 TEST_F(LocklessQueueTest, WrappedSend) {
   PinForTest pin_cpu;
   uint64_t kNumMessages = 0x100010000ul;
diff --git a/aos/ipc_lib/queue_racer.cc b/aos/ipc_lib/queue_racer.cc
index b738805..414b7fb 100644
--- a/aos/ipc_lib/queue_racer.cc
+++ b/aos/ipc_lib/queue_racer.cc
@@ -26,7 +26,23 @@
 
 QueueRacer::QueueRacer(LocklessQueue queue, int num_threads,
                        uint64_t num_messages)
-    : queue_(queue), num_threads_(num_threads), num_messages_(num_messages) {
+    : queue_(queue),
+      num_threads_(num_threads),
+      num_messages_(num_messages),
+      channel_storage_duration_(std::chrono::nanoseconds(1)),
+      expected_send_results_({LocklessQueueSender::Result::GOOD}),
+      check_writes_and_reads_(true) {
+  Reset();
+}
+
+QueueRacer::QueueRacer(LocklessQueue queue,
+                       const QueueRacerConfiguration &config)
+    : queue_(queue),
+      num_threads_(config.num_threads),
+      num_messages_(config.num_messages),
+      channel_storage_duration_(config.channel_storage_duration),
+      expected_send_results_(config.expected_send_results),
+      check_writes_and_reads_(config.check_writes_and_reads) {
   Reset();
 }
 
@@ -117,7 +133,9 @@
           EXPECT_NE(latest_queue_index_queue_index, QueueIndex::Invalid());
           // latest_queue_index is an index, not a count.  So it always reads 1
           // low.
-          EXPECT_GE(latest_queue_index + 1, finished_writes);
+          if (check_writes_and_reads_) {
+            EXPECT_GE(latest_queue_index + 1, finished_writes);
+          }
         }
       }
     }
@@ -133,8 +151,8 @@
     }
     t.thread = ::std::thread([this, &t, thread_index, &run,
                               write_wrap_count]() {
-      // Build up a sender.
-      LocklessQueueSender sender = LocklessQueueSender::Make(queue_).value();
+      LocklessQueueSender sender =
+          LocklessQueueSender::Make(queue_, channel_storage_duration_).value();
       CHECK_GE(sender.size(), sizeof(ThreadPlusCount));
 
       // Signal that we are ready to start sending.
@@ -176,9 +194,16 @@
         }
 
         ++started_writes_;
-        sender.Send(sizeof(ThreadPlusCount), aos::monotonic_clock::min_time,
-                    aos::realtime_clock::min_time, 0xffffffff, UUID::Zero(),
-                    nullptr, nullptr, nullptr);
+        auto result =
+            sender.Send(sizeof(ThreadPlusCount), aos::monotonic_clock::min_time,
+                        aos::realtime_clock::min_time, 0xffffffff, UUID::Zero(),
+                        nullptr, nullptr, nullptr);
+
+        CHECK(std::find(expected_send_results_.begin(),
+                        expected_send_results_.end(),
+                        result) != expected_send_results_.end())
+            << "Unexpected send result: " << result;
+
         // Blank out the new scratch buffer, to catch other people using it.
         {
           char *const new_data = static_cast<char *>(sender.Data()) +
@@ -210,7 +235,9 @@
     queue_index_racer.join();
   }
 
-  CheckReads(race_reads, write_wrap_count, &threads);
+  if (check_writes_and_reads_) {
+    CheckReads(race_reads, write_wrap_count, &threads);
+  }
 
   // Reap all the threads.
   if (race_reads) {
@@ -221,26 +248,28 @@
     queue_index_racer.join();
   }
 
-  // Confirm that the number of writes matches the expected number of writes.
-  ASSERT_EQ(num_threads_ * num_messages_ * (1 + write_wrap_count),
-            started_writes_);
-  ASSERT_EQ(num_threads_ * num_messages_ * (1 + write_wrap_count),
-            finished_writes_);
+  if (check_writes_and_reads_) {
+    // Confirm that the number of writes matches the expected number of writes.
+    ASSERT_EQ(num_threads_ * num_messages_ * (1 + write_wrap_count),
+              started_writes_);
+    ASSERT_EQ(num_threads_ * num_messages_ * (1 + write_wrap_count),
+              finished_writes_);
 
-  // And that every thread sent the right number of messages.
-  for (ThreadState &t : threads) {
-    if (will_wrap) {
-      if (!race_reads) {
-        // If we are wrapping, there is a possibility that a thread writes
-        // everything *before* we can read any of it, and it all gets
-        // overwritten.
-        ASSERT_TRUE(t.event_count == ::std::numeric_limits<uint64_t>::max() ||
-                    t.event_count == (1 + write_wrap_count) * num_messages_)
-            << ": Got " << t.event_count << " events, expected "
-            << (1 + write_wrap_count) * num_messages_;
+    // And that every thread sent the right number of messages.
+    for (ThreadState &t : threads) {
+      if (will_wrap) {
+        if (!race_reads) {
+          // If we are wrapping, there is a possibility that a thread writes
+          // everything *before* we can read any of it, and it all gets
+          // overwritten.
+          ASSERT_TRUE(t.event_count == ::std::numeric_limits<uint64_t>::max() ||
+                      t.event_count == (1 + write_wrap_count) * num_messages_)
+              << ": Got " << t.event_count << " events, expected "
+              << (1 + write_wrap_count) * num_messages_;
+        }
+      } else {
+        ASSERT_EQ(t.event_count, num_messages_);
       }
-    } else {
-      ASSERT_EQ(t.event_count, num_messages_);
     }
   }
 }
diff --git a/aos/ipc_lib/queue_racer.h b/aos/ipc_lib/queue_racer.h
index ea0238e..3e5ca94 100644
--- a/aos/ipc_lib/queue_racer.h
+++ b/aos/ipc_lib/queue_racer.h
@@ -10,11 +10,28 @@
 
 struct ThreadState;
 
+struct QueueRacerConfiguration {
+  // Number of threads that send messages
+  const int num_threads;
+  // Number of messages sent by each thread
+  const uint64_t num_messages;
+  // Allows QueueRacer to check for multiple returns from calling Send()
+  const std::vector<LocklessQueueSender::Result> expected_send_results = {
+      LocklessQueueSender::Result::GOOD};
+  // Channel Storage Duration for queue used by QueueRacer
+  const monotonic_clock::duration channel_storage_duration =
+      std::chrono::nanoseconds(1);
+  // Set to true if all writes and reads are expected to be successful
+  // This allows QueueRacer to be used for checking failure scenarios
+  const bool check_writes_and_reads;
+};
+
 // Class to test the queue by spinning up a bunch of writing threads and racing
 // them together to all write at once.
 class QueueRacer {
  public:
   QueueRacer(LocklessQueue queue, int num_threads, uint64_t num_messages);
+  QueueRacer(LocklessQueue queue, const QueueRacerConfiguration &config);
 
   // Runs an iteration of the race.
   //
@@ -52,7 +69,10 @@
   LocklessQueue queue_;
   const uint64_t num_threads_;
   const uint64_t num_messages_;
-
+  const monotonic_clock::duration channel_storage_duration_;
+  // Allows QueueRacer to check for multiple returns from calling Send()
+  const std::vector<LocklessQueueSender::Result> expected_send_results_;
+  const bool check_writes_and_reads_;
   // The overall number of writes executed will always be between the two of
   // these.  We can't atomically count writes, so we have to bound them.
   //
diff --git a/aos/network/message_bridge_test_combined_timestamps_common.json b/aos/network/message_bridge_test_combined_timestamps_common.json
index 74c932d..be79014 100644
--- a/aos/network/message_bridge_test_combined_timestamps_common.json
+++ b/aos/network/message_bridge_test_combined_timestamps_common.json
@@ -20,7 +20,7 @@
       "name": "/pi1/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "pi1",
-      "frequency": 10,
+      "frequency": 15,
       "max_size": 200,
       "destination_nodes": [
         {
@@ -36,7 +36,7 @@
       "name": "/pi2/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "pi2",
-      "frequency": 10,
+      "frequency": 15,
       "max_size": 200,
       "destination_nodes": [
         {
@@ -64,25 +64,25 @@
       "name": "/pi1/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "pi1",
-      "frequency": 2
+      "frequency": 15
     },
     {
       "name": "/pi2/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "pi2",
-      "frequency": 2
+      "frequency": 15
     },
     {
       "name": "/pi1/aos/remote_timestamps/pi2",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi1",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi2/aos/remote_timestamps/pi1",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi2",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi1/aos",
diff --git a/aos/network/message_bridge_test_common.json b/aos/network/message_bridge_test_common.json
index 99c80a9..4623edb 100644
--- a/aos/network/message_bridge_test_common.json
+++ b/aos/network/message_bridge_test_common.json
@@ -20,7 +20,7 @@
       "name": "/pi1/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "pi1",
-      "frequency": 10,
+      "frequency": 15,
       "max_size": 200,
       "destination_nodes": [
         {
@@ -36,7 +36,7 @@
       "name": "/pi2/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "pi2",
-      "frequency": 10,
+      "frequency": 15,
       "max_size": 200,
       "destination_nodes": [
         {
@@ -64,43 +64,43 @@
       "name": "/pi1/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "pi1",
-      "frequency": 2
+      "frequency": 15
     },
     {
       "name": "/pi2/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "pi2",
-      "frequency": 2
+      "frequency": 15
     },
     {
       "name": "/pi1/aos/remote_timestamps/pi2/pi1/aos/aos-message_bridge-Timestamp",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi1",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi2/aos/remote_timestamps/pi1/pi2/aos/aos-message_bridge-Timestamp",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi2",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi1/aos/remote_timestamps/pi2/test/aos-examples-Ping",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi1",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi2/aos/remote_timestamps/pi1/test/aos-examples-Pong",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi2",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi1/aos/remote_timestamps/pi2/unreliable/aos-examples-Ping",
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "pi1",
-      "frequency": 10
+      "frequency": 15
     },
     {
       "name": "/pi1/aos",
diff --git a/aos/network/multinode_timestamp_filter.cc b/aos/network/multinode_timestamp_filter.cc
index 0619b5e..262cb5c 100644
--- a/aos/network/multinode_timestamp_filter.cc
+++ b/aos/network/multinode_timestamp_filter.cc
@@ -43,6 +43,65 @@
 // ms/s.  Figure out how to define it.  Do this last.  This lets us handle
 // constraints going away, and constraints close in time.
 
+bool TimestampProblem::HasObservations(size_t node_a) const {
+  // Note, this function is probably over conservative.  It is requiring all the
+  // pairs for a node to have data in at least one direction rather than enough
+  // pairs to have data to observe the graph.  We can break that when someone
+  // finds it is overly restrictive.
+
+  if (clock_offset_filter_for_node_[node_a].empty()) {
+    // Look for a filter going the other way who's node_b is our node.
+    bool found_filter = false;
+    for (size_t node_b = 0u; node_b < clock_offset_filter_for_node_.size();
+         ++node_b) {
+      for (const struct FilterPair &filter :
+           clock_offset_filter_for_node_[node_b]) {
+        if (filter.b_index == node_a) {
+          if (filter.filter->timestamps_size(base_clock_[node_b].boot,
+                                             base_clock_[node_a].boot) == 0u) {
+            // Found one without data, explode.
+            return false;
+          }
+          found_filter = true;
+        }
+      }
+    }
+    return found_filter;
+  }
+
+  for (const struct FilterPair &filter :
+       clock_offset_filter_for_node_[node_a]) {
+    // There's something in this direction, so we don't need to check the
+    // opposite direction to confirm we have observations.
+    if (filter.filter->timestamps_size(
+            base_clock_[node_a].boot, base_clock_[filter.b_index].boot) != 0u) {
+      continue;
+    }
+
+    // For a boot to exist, we need to have some observations between it and
+    // another boot.  We wouldn't bother to build a problem to solve for
+    // this node otherwise.  Confirm that is true so we at least get
+    // notified if that assumption falls apart.
+    bool valid = false;
+    for (const struct FilterPair &other_filter :
+         clock_offset_filter_for_node_[filter.b_index]) {
+      if (other_filter.b_index == node_a) {
+        // Found our match.  Confirm it has timestamps.
+        if (other_filter.filter->timestamps_size(
+                base_clock_[filter.b_index].boot, base_clock_[node_a].boot) !=
+            0u) {
+          valid = true;
+        }
+        break;
+      }
+    }
+    if (!valid) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool TimestampProblem::ValidateSolution(std::vector<BootTimestamp> solution) {
   bool success = true;
   for (size_t i = 0u; i < clock_offset_filter_for_node_.size(); ++i) {
@@ -1355,16 +1414,15 @@
 
 std::tuple<std::vector<MultiNodeNoncausalOffsetEstimator::CandidateTimes>, bool>
 MultiNodeNoncausalOffsetEstimator::MakeCandidateTimes() const {
-  bool boots_all_match = true;
   std::vector<CandidateTimes> candidate_times;
   candidate_times.resize(last_monotonics_.size());
 
   size_t node_a_index = 0;
-  size_t last_boot = std::numeric_limits<size_t>::max();
   for (const auto &filters : filters_per_node_) {
     VLOG(2) << "Investigating filter for node " << node_a_index;
     BootTimestamp next_node_time = BootTimestamp::max_time();
-    BootDuration next_node_duration;
+    BootDuration next_node_duration = BootDuration::max_time();
+    size_t b_index = std::numeric_limits<size_t>::max();
     NoncausalTimestampFilter *next_node_filter = nullptr;
     // Find the oldest time for each node in each filter, and solve for that
     // time.  That gives us the next timestamp for this node.
@@ -1379,23 +1437,13 @@
         if (std::get<0>(*candidate) < next_node_time) {
           next_node_time = std::get<0>(*candidate);
           next_node_duration = std::get<1>(*candidate);
+          b_index = filter.b_index;
           next_node_filter = filter.filter;
         }
       }
       ++filter_index;
     }
 
-    // Found no active filters.  Either this node is off, or disconnected, or
-    // we are before the log file starts or after the log file ends.
-    if (next_node_time == BootTimestamp::max_time()) {
-      candidate_times[node_a_index] =
-          CandidateTimes{.next_node_time = next_node_time,
-                         .next_node_duration = next_node_duration,
-                         .next_node_filter = next_node_filter};
-      ++node_a_index;
-      continue;
-    }
-
     // We want to make sure we solve explicitly for the start time for each
     // log.  This is useless (though not all that expensive) if it is in the
     // middle of a set of data since we are just adding an extra point in the
@@ -1419,6 +1467,8 @@
                 << " is the next startup time, " << next_start_time;
         next_node_time = next_start_time;
         next_node_filter = nullptr;
+        b_index = std::numeric_limits<size_t>::max();
+        next_node_duration = BootDuration::max_time();
       }
 
       // We need to make sure we have solutions as well for any local messages
@@ -1436,19 +1486,56 @@
                 << " not applying yet";
         next_node_time = next_oldest_time;
         next_node_filter = nullptr;
+        b_index = std::numeric_limits<size_t>::max();
+        next_node_duration = BootDuration::max_time();
       }
     }
-    if (last_boot != std::numeric_limits<size_t>::max()) {
-      boots_all_match &= (next_node_time.boot == last_boot);
-    }
-    last_boot = next_node_time.boot;
     candidate_times[node_a_index] =
         CandidateTimes{.next_node_time = next_node_time,
                        .next_node_duration = next_node_duration,
+                       .b_index = b_index,
                        .next_node_filter = next_node_filter};
     ++node_a_index;
   }
 
+  // Now that we have all the candidates, confirm everything matches.
+  bool boots_all_match = true;
+  for (size_t i = 0; i < candidate_times.size(); ++i) {
+    const CandidateTimes &candidate = candidate_times[i];
+    if (candidate.next_node_time == logger::BootTimestamp::max_time()) {
+      continue;
+    }
+
+    // First step, if the last solution's boot doesn't match the next solution,
+    // we've got a reboot incoming and can't sort well.  Fall back to the more
+    // basic exhaustive search.
+    if (candidate.next_node_time.boot != last_monotonics_[i].boot) {
+      boots_all_match = false;
+      break;
+    }
+
+    // And then check that the other node's time also hasn't rebooted.  We might
+    // not have both directions of timestamps, so this is our only clue.
+    if (candidate.next_node_duration == BootDuration::max_time()) {
+      continue;
+    }
+
+    DCHECK_LT(candidate.b_index, candidate_times.size());
+    if (candidate_times[candidate.b_index].next_node_time.boot !=
+        candidate.next_node_duration.boot) {
+      boots_all_match = false;
+      break;
+    }
+  }
+  if (VLOG_IS_ON(1)) {
+    LOG(INFO) << "Boots all match: " << boots_all_match;
+    for (size_t i = 0; i < candidate_times.size(); ++i) {
+      LOG(INFO) << "Candidate " << candidate_times[i].next_node_time
+                << " duration " << candidate_times[i].next_node_duration
+                << " (node " << candidate_times[i].b_index << ")";
+    }
+  }
+
   return std::make_tuple(candidate_times, boots_all_match);
 }
 
@@ -1572,6 +1659,7 @@
         candidate_times[node_a_index].next_node_duration;
     NoncausalTimestampFilter *next_node_filter =
         candidate_times[node_a_index].next_node_filter;
+    size_t b_index = candidate_times[node_a_index].b_index;
     if (next_node_time == BootTimestamp::max_time()) {
       continue;
     }
@@ -1586,8 +1674,16 @@
     // TODO(austin): If we start supporting only having 1 direction of
     // timestamps, we might need to change our assumptions around
     // BootTimestamp and BootDuration.
+    bool boots_match = next_node_time.boot == base_times[node_a_index].boot;
 
-    if (next_node_time.boot == base_times[node_a_index].boot) {
+    // Make sure the paired time also has a matching boot.
+    if (next_node_duration != BootDuration::max_time()) {
+      if (next_node_duration.boot != base_times[b_index].boot) {
+        boots_match = false;
+      }
+    }
+
+    if (boots_match) {
       // Optimize, and save the time into times if earlier than time.
       for (size_t node_index = 0; node_index < base_times.size();
            ++node_index) {
@@ -1609,6 +1705,16 @@
       // And we know our solution node will have the wrong boot, so replace
       // it entirely.
       problem->set_base_clock(node_a_index, next_node_time);
+
+      // And update the paired boot for the paired node.
+      if (next_node_duration != BootDuration::max_time()) {
+        if (next_node_duration.boot != base_times[b_index].boot) {
+          problem->set_base_clock(
+              b_index, BootTimestamp{.boot = next_node_duration.boot,
+                                     .time = next_node_time.time +
+                                             next_node_duration.duration});
+        }
+      }
     }
 
     std::vector<BootTimestamp> points(problem->size(),
@@ -1617,6 +1723,14 @@
       problem->Debug();
     }
     points[node_a_index] = next_node_time;
+
+    if (!problem->HasObservations(node_a_index)) {
+      VLOG(1) << "No observations, checking if there's a filter";
+      CHECK(next_node_filter == nullptr)
+          << ": No observations, but this isn't a start time.";
+      continue;
+    }
+
     std::tuple<std::vector<BootTimestamp>, size_t> solution =
         problem->SolveNewton(points);
 
diff --git a/aos/network/multinode_timestamp_filter.h b/aos/network/multinode_timestamp_filter.h
index 7259fc8..f959d7b 100644
--- a/aos/network/multinode_timestamp_filter.h
+++ b/aos/network/multinode_timestamp_filter.h
@@ -61,6 +61,10 @@
   // Validates the solution, returning true if it meets all the constraints, and
   // false otherwise.
   bool ValidateSolution(std::vector<logger::BootTimestamp> solution);
+  // Returns true if the provide node has observations to solve for the
+  // provided boots.  This may happen when we are trying to solve for a reboot
+  // to see if it is next, and haven't queued far enough.
+  bool HasObservations(size_t node_a) const;
 
   // LOGs a representation of the problem.
   void Debug();
@@ -331,7 +335,8 @@
  private:
   struct CandidateTimes {
     logger::BootTimestamp next_node_time = logger::BootTimestamp::max_time();
-    logger::BootDuration next_node_duration;
+    logger::BootDuration next_node_duration = logger::BootDuration::max_time();
+    size_t b_index = std::numeric_limits<size_t>::max();
     NoncausalTimestampFilter *next_node_filter = nullptr;
   };
 
diff --git a/aos/network/timestamp_channel.cc b/aos/network/timestamp_channel.cc
index ab61051..fdaa031 100644
--- a/aos/network/timestamp_channel.cc
+++ b/aos/network/timestamp_channel.cc
@@ -2,6 +2,10 @@
 
 #include "absl/strings/str_cat.h"
 
+DEFINE_bool(combined_timestamp_channel_fallback, true,
+            "If true, fall back to using the combined timestamp channel if the "
+            "single timestamp channel doesn't exist for a timestamp.");
+
 namespace aos {
 namespace message_bridge {
 
@@ -12,7 +16,8 @@
 
 std::string ChannelTimestampFinder::SplitChannelName(
     const Channel *channel, const Connection *connection) {
-  return SplitChannelName(channel->name()->string_view(), channel->type()->str(), connection);
+  return SplitChannelName(channel->name()->string_view(),
+                          channel->type()->str(), connection);
 }
 
 std::string ChannelTimestampFinder::SplitChannelName(
@@ -47,6 +52,15 @@
     return split_timestamp_channel;
   }
 
+  if (!FLAGS_combined_timestamp_channel_fallback) {
+    LOG(FATAL) << "Failed to find new timestamp channel {\"name\": \""
+               << split_timestamp_channel_name << "\", \"type\": \""
+               << RemoteMessage::GetFullyQualifiedName() << "\"} for "
+               << configuration::CleanedChannelToString(channel)
+               << " connection " << aos::FlatbufferToJson(connection)
+               << " and --nocombined_timestamp_channel_fallback is set";
+  }
+
   const std::string shared_timestamp_channel_name =
       CombinedChannelName(connection->name()->string_view());
   const Channel *shared_timestamp_channel = configuration::GetChannel(
diff --git a/aos/network/timestamp_filter.h b/aos/network/timestamp_filter.h
index 6486a1b..b51fe2f 100644
--- a/aos/network/timestamp_filter.h
+++ b/aos/network/timestamp_filter.h
@@ -696,7 +696,9 @@
     auto it =
         std::lower_bound(filters_.begin(), filters_.end(),
                          std::make_pair(boota, bootb), FilterLessThanLower);
-    CHECK(it != filters_.end());
+    if (it == filters_.end()) {
+      return nullptr;
+    }
     if (it->boot == std::make_pair(boota, bootb)) {
       return &it->filter;
     } else {
diff --git a/aos/network/www/aos_plotter.ts b/aos/network/www/aos_plotter.ts
index b7d8771..cd2e131 100644
--- a/aos/network/www/aos_plotter.ts
+++ b/aos/network/www/aos_plotter.ts
@@ -28,7 +28,7 @@
 import {Connection} from 'org_frc971/aos/network/www/proxy';
 import {SubscriberRequest, ChannelRequest, TransferMethod} from 'org_frc971/aos/network/web_proxy_generated';
 import {Parser, Table} from 'org_frc971/aos/network/www/reflection'
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 import {ByteBuffer} from 'flatbuffers';
 
 export class TimestampedMessage {
diff --git a/aos/network/www/proxy.ts b/aos/network/www/proxy.ts
index cf8e972..0bda8b9 100644
--- a/aos/network/www/proxy.ts
+++ b/aos/network/www/proxy.ts
@@ -1,7 +1,7 @@
 import {Builder, ByteBuffer, Offset} from 'flatbuffers';
 import {Channel as ChannelFb, Configuration} from 'org_frc971/aos/configuration_generated';
 import {ChannelRequest as ChannelRequestFb, ChannelState, MessageHeader, Payload, SdpType, SubscriberRequest, TransferMethod, WebSocketIce, WebSocketMessage, WebSocketSdp} from 'org_frc971/aos/network/web_proxy_generated';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 
 // There is one handler for each DataChannel, it maintains the state of
 // multi-part messages and delegates to a callback when the message is fully
diff --git a/aos/starter/BUILD b/aos/starter/BUILD
index 2186421..5bf3811 100644
--- a/aos/starter/BUILD
+++ b/aos/starter/BUILD
@@ -33,6 +33,7 @@
         "//aos/events:event_loop",
         "//aos/events:shm_event_loop",
         "//aos/util:scoped_pipe",
+        "//aos/util:top",
         "@com_github_google_glog//:glog",
     ],
 )
@@ -99,6 +100,8 @@
         "//aos/events:pingpong_config",
         "//aos/events:pong",
     ],
+    # TODO(james): Fix tihs.
+    flaky = True,
     linkopts = ["-lstdc++fs"],
     shard_count = 4,
     # The roborio compiler doesn't support <filesystem>.
@@ -163,6 +166,7 @@
     name = "starter_fbs",
     srcs = ["starter.fbs"],
     gen_reflections = True,
+    includes = ["//aos/util:process_info_fbs_includes"],
     target_compatible_with = ["@platforms//os:linux"],
     visibility = ["//visibility:public"],
 )
diff --git a/aos/starter/starter.fbs b/aos/starter/starter.fbs
index 4b66833..7285281 100644
--- a/aos/starter/starter.fbs
+++ b/aos/starter/starter.fbs
@@ -1,3 +1,5 @@
+include "aos/util/process_info.fbs";
+
 namespace aos.starter;
 
 enum State : short {
@@ -73,6 +75,13 @@
   // Indicates the reason the application is not running. Only valid if
   // application is STOPPED.
   last_stop_reason: LastStopReason (id: 6);
+
+  // Debug information providing the approximate CPU usage and memory footprint of the process.
+  // Populated whenever the process is running (i.e., state != STOPPED). While STOPPING could
+  // refer to another process if another process has somehow claimed the application's PID between
+  // actually stopping and the parent process receiving the signal indicating that the application
+  // finished stopping.
+  process_info: util.ProcessInfo (id: 7);
 }
 
 root_type Status;
diff --git a/aos/starter/starter_test.cc b/aos/starter/starter_test.cc
index 120fe38..06f961a 100644
--- a/aos/starter/starter_test.cc
+++ b/aos/starter/starter_test.cc
@@ -27,8 +27,22 @@
   }
 
  protected:
+  void SetupStarterCleanup(aos::starter::Starter *starter) {
+    starter->event_loop()
+        ->AddTimer([this, starter]() {
+          if (test_done_) {
+            starter->Cleanup();
+          }
+        })
+        ->Setup(starter->event_loop()->monotonic_now(),
+                std::chrono::seconds(1));
+  }
+
   gflags::FlagSaver flag_saver_;
   std::string shm_dir_;
+  // Used to track when the test completes so that we can clean up the starter
+  // in its thread.
+  std::atomic<bool> test_done_{false};
 };
 
 struct TestParams {
@@ -145,11 +159,13 @@
         }
       });
 
+  SetupStarterCleanup(&starter);
+
   std::thread starterd_thread([&starter] { starter.Run(); });
   std::thread client_thread([&client_loop] { client_loop.Run(); });
   watcher_loop.Run();
 
-  starter.Cleanup();
+  test_done_ = true;
   client_thread.join();
   starterd_thread.join();
 }
@@ -239,10 +255,13 @@
     }
   });
 
+  SetupStarterCleanup(&starter);
+
   std::thread starterd_thread([&starter] { starter.Run(); });
   watcher_loop.Run();
 
-  starter.Cleanup();
+  test_done_ = true;
+
   starterd_thread.join();
 }
 
@@ -287,32 +306,51 @@
       })
       ->Setup(watcher_loop.monotonic_now() + std::chrono::seconds(7));
 
-  watcher_loop.MakeWatcher(
-      "/aos", [&watcher_loop](const aos::starter::Status &status) {
-        const aos::starter::ApplicationStatus *ping_app_status =
-            FindApplicationStatus(status, "ping");
-        const aos::starter::ApplicationStatus *pong_app_status =
-            FindApplicationStatus(status, "pong");
-        if (ping_app_status == nullptr || pong_app_status == nullptr) {
-          return;
-        }
+  int pong_running_count = 0;
+  watcher_loop.MakeWatcher("/aos", [&watcher_loop, &pong_running_count](
+                                       const aos::starter::Status &status) {
+    const aos::starter::ApplicationStatus *ping_app_status =
+        FindApplicationStatus(status, "ping");
+    const aos::starter::ApplicationStatus *pong_app_status =
+        FindApplicationStatus(status, "pong");
+    if (ping_app_status == nullptr || pong_app_status == nullptr) {
+      return;
+    }
 
-        if (ping_app_status->has_state() &&
-            ping_app_status->state() != aos::starter::State::STOPPED) {
-          watcher_loop.Exit();
-          FAIL();
-        }
-        if (pong_app_status->has_state() &&
-            pong_app_status->state() == aos::starter::State::RUNNING) {
-          watcher_loop.Exit();
-          SUCCEED();
-        }
-      });
+    if (ping_app_status->has_state() &&
+        ping_app_status->state() != aos::starter::State::STOPPED) {
+      watcher_loop.Exit();
+      FAIL();
+    }
+    if (pong_app_status->has_state() &&
+        pong_app_status->state() == aos::starter::State::RUNNING) {
+      ++pong_running_count;
+      // Sometimes if the timing for everything is *just* off, then the
+      // process_info will say that the process name is "starter_test" because
+      // it grabbed the name after the fork() but before the execvp(). To
+      // protect against that, wait an extra cycle. If things aren't fixed by
+      // the second cycle, then that is a problem.
+      if (pong_running_count < 2) {
+        return;
+      }
+      ASSERT_TRUE(pong_app_status->has_process_info());
+      ASSERT_EQ("pong", pong_app_status->process_info()->name()->string_view())
+          << aos::FlatbufferToJson(&status);
+      ASSERT_EQ(pong_app_status->pid(), pong_app_status->process_info()->pid());
+      ASSERT_TRUE(pong_app_status->process_info()->has_cpu_usage());
+      ASSERT_LE(0.0, pong_app_status->process_info()->cpu_usage());
+      watcher_loop.Exit();
+      SUCCEED();
+    }
+  });
+
+  SetupStarterCleanup(&starter);
 
   std::thread starterd_thread([&starter] { starter.Run(); });
   watcher_loop.Run();
 
-  starter.Cleanup();
+  test_done_ = true;
+
   starterd_thread.join();
 }
 
@@ -399,10 +437,14 @@
     }
   });
 
+
+  SetupStarterCleanup(&starter);
+
   std::thread starterd_thread([&starter] { starter.Run(); });
   watcher_loop.Run();
 
-  starter.Cleanup();
+  test_done_ = true;
+
   starterd_thread.join();
 }
 
diff --git a/aos/starter/starterd_lib.cc b/aos/starter/starterd_lib.cc
index 008c46f..84e4d00 100644
--- a/aos/starter/starterd_lib.cc
+++ b/aos/starter/starterd_lib.cc
@@ -33,7 +33,8 @@
           event_loop_.GetChannel<aos::starter::Status>("/aos")->frequency() -
           1),
       listener_(&event_loop_,
-                [this](signalfd_siginfo signal) { OnSignal(signal); }) {
+                [this](signalfd_siginfo signal) { OnSignal(signal); }),
+      top_(&event_loop_) {
   event_loop_.SkipAosLog();
 
   event_loop_.OnRun([this] {
@@ -117,7 +118,16 @@
   }
 }
 
-void Starter::MaybeSendStatus() {
+void Starter::HandleStateChange() {
+  std::set<pid_t> all_pids;
+  for (const auto &pair : applications_) {
+    if (pair.second.get_pid() > 0 &&
+        pair.second.status() != aos::starter::State::STOPPED) {
+      all_pids.insert(pair.second.get_pid());
+    }
+  }
+  top_.set_track_pids(all_pids);
+
   if (status_count_ < max_status_count_) {
     SendStatus();
     ++status_count_;
@@ -165,9 +175,9 @@
 }
 
 Application *Starter::AddApplication(const aos::Application *application) {
-  auto [iter, success] =
-      applications_.try_emplace(application->name()->str(), application,
-                                &event_loop_, [this]() { MaybeSendStatus(); });
+  auto [iter, success] = applications_.try_emplace(
+      application->name()->str(), application, &event_loop_,
+      [this]() { HandleStateChange(); });
   if (success) {
     // We should be catching and handling SIGCHLD correctly in the starter, so
     // don't leave in the crutch for polling for the child process status (this
@@ -200,7 +210,7 @@
   std::vector<flatbuffers::Offset<aos::starter::ApplicationStatus>> statuses;
 
   for (auto &application : applications_) {
-    statuses.push_back(application.second.PopulateStatus(builder.fbb()));
+    statuses.push_back(application.second.PopulateStatus(builder.fbb(), &top_));
   }
 
   auto statuses_fbs = builder.fbb()->CreateVector(statuses);
diff --git a/aos/starter/starterd_lib.h b/aos/starter/starterd_lib.h
index 834e191..66549ef 100644
--- a/aos/starter/starterd_lib.h
+++ b/aos/starter/starterd_lib.h
@@ -17,6 +17,7 @@
 #include "aos/starter/starter_generated.h"
 #include "aos/starter/starter_rpc_generated.h"
 #include "aos/starter/subprocess.h"
+#include "aos/util/top.h"
 
 namespace aos {
 namespace starter {
@@ -40,6 +41,10 @@
 
   void Cleanup();
 
+  // EventLoop that we use for running the code. Mostly exposed for testing
+  // purposes.
+  EventLoop *event_loop() { return &event_loop_; }
+
  private:
   // Signals which indicate starter has died
   static const inline std::vector<int> kStarterDeath = {
@@ -49,8 +54,10 @@
   void OnSignal(signalfd_siginfo signal);
   void HandleStarterRpc(const StarterRpc &command);
 
-  // Sends the Status message if it wouldn't exceed the rate limit.
-  void MaybeSendStatus();
+  // Handles any potential state change in the child applications.
+  // In particular, sends the Status message if it wouldn't exceed the rate
+  // limit.
+  void HandleStateChange();
 
   void SendStatus();
 
@@ -73,6 +80,8 @@
 
   SignalListener listener_;
 
+  util::Top top_;
+
   DISALLOW_COPY_AND_ASSIGN(Starter);
 };
 
diff --git a/aos/starter/subprocess.cc b/aos/starter/subprocess.cc
index c1eb618..f0c8f85 100644
--- a/aos/starter/subprocess.cc
+++ b/aos/starter/subprocess.cc
@@ -346,10 +346,16 @@
 }
 
 flatbuffers::Offset<aos::starter::ApplicationStatus>
-Application::PopulateStatus(flatbuffers::FlatBufferBuilder *builder) {
+Application::PopulateStatus(flatbuffers::FlatBufferBuilder *builder,
+                            util::Top *top) {
   CHECK_NOTNULL(builder);
   auto name_fbs = builder->CreateString(name_);
 
+  const bool valid_pid = pid_ > 0 && status_ != aos::starter::State::STOPPED;
+  const flatbuffers::Offset<util::ProcessInfo> process_info =
+      valid_pid ? top->InfoForProcess(builder, pid_)
+                : flatbuffers::Offset<util::ProcessInfo>();
+
   aos::starter::ApplicationStatus::Builder status_builder(*builder);
   status_builder.add_name(name_fbs);
   status_builder.add_state(status_);
@@ -361,6 +367,8 @@
     status_builder.add_pid(pid_);
     status_builder.add_id(id_);
   }
+  // Note that even if process_info is null, calling add_process_info is fine.
+  status_builder.add_process_info(process_info);
   status_builder.add_last_start_time(start_time_.time_since_epoch().count());
   return status_builder.Finish();
 }
diff --git a/aos/starter/subprocess.h b/aos/starter/subprocess.h
index 9ee9e31..a4d7cbb 100644
--- a/aos/starter/subprocess.h
+++ b/aos/starter/subprocess.h
@@ -11,6 +11,7 @@
 #include "aos/starter/starter_generated.h"
 #include "aos/starter/starter_rpc_generated.h"
 #include "aos/util/scoped_pipe.h"
+#include "aos/util/top.h"
 
 namespace aos::starter {
 
@@ -45,7 +46,7 @@
               aos::EventLoop *event_loop, std::function<void()> on_change);
 
   flatbuffers::Offset<aos::starter::ApplicationStatus> PopulateStatus(
-      flatbuffers::FlatBufferBuilder *builder);
+      flatbuffers::FlatBufferBuilder *builder, util::Top *top);
   aos::starter::State status() const { return status_; };
 
   // Returns the last pid of this process. -1 if not started yet.
diff --git a/aos/util/BUILD b/aos/util/BUILD
index 3b96cfd..8d21c47 100644
--- a/aos/util/BUILD
+++ b/aos/util/BUILD
@@ -1,3 +1,5 @@
+load("@com_github_google_flatbuffers//:build_defs.bzl", "flatbuffer_cc_library")
+
 package(default_visibility = ["//visibility:public"])
 
 cc_library(
@@ -272,6 +274,45 @@
     ],
 )
 
+flatbuffer_cc_library(
+    name = "process_info_fbs",
+    srcs = ["process_info.fbs"],
+    gen_reflections = True,
+    target_compatible_with = ["@platforms//os:linux"],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "top",
+    srcs = ["top.cc"],
+    hdrs = ["top.h"],
+    target_compatible_with = ["@platforms//os:linux"],
+    deps = [
+        ":process_info_fbs",
+        "//aos/containers:ring_buffer",
+        "//aos/events:event_loop",
+        "@com_github_google_glog//:glog",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "top_test",
+    srcs = ["top_test.cc"],
+    data = [
+        "//aos/events:pingpong_config",
+    ],
+    flaky = True,
+    target_compatible_with = ["@platforms//os:linux"],
+    deps = [
+        ":top",
+        "//aos/events:shm_event_loop",
+        "//aos/testing:googletest",
+        "//aos/testing:path",
+        "//aos/testing:tmpdir",
+    ],
+)
+
 cc_library(
     name = "scoped_pipe",
     srcs = ["scoped_pipe.cc"],
diff --git a/aos/util/mcap_logger.cc b/aos/util/mcap_logger.cc
index 9ab4012..1cb9c32 100644
--- a/aos/util/mcap_logger.cc
+++ b/aos/util/mcap_logger.cc
@@ -4,6 +4,11 @@
 #include "single_include/nlohmann/json.hpp"
 
 namespace aos {
+namespace {
+// Amount of data to allow in each chunk before creating a new chunk.
+constexpr size_t kChunkSize = 10000000;
+}
+
 nlohmann::json JsonSchemaForFlatbuffer(const FlatbufferType &type,
                                        JsonSchemaRecursion recursion_level) {
   nlohmann::json schema;
@@ -71,39 +76,100 @@
 }
 
 McapLogger::McapLogger(EventLoop *event_loop, const std::string &output_path)
-    : output_(output_path) {
+    : event_loop_(event_loop), output_(output_path) {
   event_loop->SkipTimingReport();
   event_loop->SkipAosLog();
   CHECK(output_);
   WriteMagic();
   WriteHeader();
-  uint16_t id = 1;
-  for (const Channel *channel : *event_loop->configuration()->channels()) {
-    if (!configuration::ChannelIsReadableOnNode(channel, event_loop->node())) {
-      continue;
-    }
-
-    WriteSchema(id, channel);
-
-    // Write out the channel entry that uses the schema (we just re-use the
-    // chema ID for the channel ID, since we aren't deduplicating schemas for
-    // channels that are of the same type).
-    WriteChannel(id, id, channel);
-
-    event_loop->MakeRawWatcher(
-        channel, [this, id, channel](const Context &context, const void *) {
-          WriteMessage(id, channel, context);
-        });
-    ++id;
-  }
+  // Schemas and channels get written out both at the start and end of the file,
+  // per the MCAP spec.
+  WriteSchemasAndChannels(RegisterHandlers::kYes);
 }
 
 McapLogger::~McapLogger() {
+  // If we have any data remaining, write one last chunk.
+  if (current_chunk_.tellp() > 0) {
+    WriteChunk();
+  }
   WriteDataEnd();
-  WriteFooter();
+
+  // Now we enter the Summary section, where we write out all the channel/index
+  // information that readers need to be able to seek to arbitrary locations
+  // within the log.
+  const uint64_t summary_offset = output_.tellp();
+  const SummaryOffset chunk_indices_offset = WriteChunkIndices();
+  const SummaryOffset stats_offset = WriteStatistics();
+  // Schemas/Channels need to get reproduced in the summary section for random
+  // access reading.
+  const std::vector<SummaryOffset> offsets =
+      WriteSchemasAndChannels(RegisterHandlers::kNo);
+
+  // Next we have the summary offset section, which references the individual
+  // pieces of the summary section.
+  const uint64_t summary_offset_offset = output_.tellp();
+
+  // SummarytOffset's must all be the final thing before the footer.
+  WriteSummaryOffset(chunk_indices_offset);
+  WriteSummaryOffset(stats_offset);
+  for (const auto &offset : offsets) {
+    WriteSummaryOffset(offset);
+  }
+
+  // And finally, the footer which must itself reference the start of the
+  // summary and summary offset sections.
+  WriteFooter(summary_offset, summary_offset_offset);
   WriteMagic();
 }
 
+std::vector<McapLogger::SummaryOffset> McapLogger::WriteSchemasAndChannels(
+    RegisterHandlers register_handlers) {
+  uint16_t id = 1;
+  std::map<uint16_t, const Channel *> channels;
+  for (const Channel *channel : *event_loop_->configuration()->channels()) {
+    if (!configuration::ChannelIsReadableOnNode(channel, event_loop_->node())) {
+      continue;
+    }
+    channels[id] = channel;
+
+    if (register_handlers == RegisterHandlers::kYes) {
+      message_counts_[id] = 0;
+      event_loop_->MakeRawWatcher(
+          channel, [this, id, channel](const Context &context, const void *) {
+            WriteMessage(id, channel, context, &current_chunk_);
+            if (static_cast<uint64_t>(current_chunk_.tellp()) > kChunkSize) {
+              WriteChunk();
+            }
+          });
+    }
+    ++id;
+  }
+
+  std::vector<SummaryOffset> offsets;
+
+  const uint64_t schema_offset = output_.tellp();
+
+  for (const auto &pair : channels) {
+    WriteSchema(pair.first, pair.second);
+  }
+
+  const uint64_t channel_offset = output_.tellp();
+
+  offsets.push_back(
+      {OpCode::kSchema, schema_offset, channel_offset - schema_offset});
+
+  for (const auto &pair : channels) {
+    // Write out the channel entry that uses the schema (we just re-use
+    // the schema ID for the channel ID, since we aren't deduplicating
+    // schemas for channels that are of the same type).
+    WriteChannel(pair.first, pair.first, pair.second);
+  }
+
+  offsets.push_back({OpCode::kChannel, channel_offset,
+                     static_cast<uint64_t>(output_.tellp()) - channel_offset});
+  return offsets;
+}
+
 void McapLogger::WriteMagic() { output_ << "\x89MCAP0\r\n"; }
 
 void McapLogger::WriteHeader() {
@@ -115,11 +181,12 @@
   WriteRecord(OpCode::kHeader, string_builder_.Result());
 }
 
-void McapLogger::WriteFooter() {
+void McapLogger::WriteFooter(uint64_t summary_offset,
+                             uint64_t summary_offset_offset) {
   string_builder_.Reset();
-  // Offsets and CRC32 for summary section, which we don't populate.
-  AppendInt64(&string_builder_, 0);
-  AppendInt64(&string_builder_, 0);
+  AppendInt64(&string_builder_, summary_offset);
+  AppendInt64(&string_builder_, summary_offset_offset);
+  // CRC32 for the Summary section, which we don't bother populating.
   AppendInt32(&string_builder_, 0);
   WriteRecord(OpCode::kFooter, string_builder_.Result());
 }
@@ -167,9 +234,19 @@
 }
 
 void McapLogger::WriteMessage(uint16_t channel_id, const Channel *channel,
-                              const Context &context) {
+                              const Context &context, std::ostream *output) {
   CHECK_NOTNULL(context.data);
 
+  message_counts_[channel_id]++;
+
+  if (!earliest_message_.has_value()) {
+    earliest_message_ = context.monotonic_event_time;
+  }
+  if (!earliest_chunk_message_.has_value()) {
+    earliest_chunk_message_ = context.monotonic_event_time;
+  }
+  latest_message_ = context.monotonic_event_time;
+
   string_builder_.Reset();
   // Channel ID
   AppendInt16(&string_builder_, channel_id);
@@ -193,15 +270,117 @@
   aos::FlatbufferToJson(&string_builder_, channel->schema(),
                         static_cast<const uint8_t *>(context.data));
 
-  WriteRecord(OpCode::kMessage, string_builder_.Result());
+  message_indices_[channel_id].push_back(std::make_pair<uint64_t, uint64_t>(
+      context.monotonic_event_time.time_since_epoch().count(),
+      output->tellp()));
+
+  WriteRecord(OpCode::kMessage, string_builder_.Result(), output);
 }
 
-void McapLogger::WriteRecord(OpCode op, std::string_view record) {
-  output_.put(static_cast<char>(op));
+void McapLogger::WriteRecord(OpCode op, std::string_view record,
+                             std::ostream *ostream) {
+  ostream->put(static_cast<char>(op));
   uint64_t record_length = record.size();
-  output_.write(reinterpret_cast<const char *>(&record_length),
-                sizeof(record_length));
-  output_ << record;
+  ostream->write(reinterpret_cast<const char *>(&record_length),
+                 sizeof(record_length));
+  *ostream << record;
+}
+
+void McapLogger::WriteChunk() {
+  string_builder_.Reset();
+
+  CHECK(earliest_chunk_message_.has_value());
+  const uint64_t chunk_offset = output_.tellp();
+  AppendInt64(&string_builder_,
+              earliest_chunk_message_->time_since_epoch().count());
+  AppendInt64(&string_builder_, latest_message_.time_since_epoch().count());
+
+  std::string chunk_records = current_chunk_.str();
+  // Reset the chunk buffer.
+  current_chunk_.str("");
+
+  const uint64_t records_size = chunk_records.size();
+  // Uncompressed chunk size.
+  AppendInt64(&string_builder_, records_size);
+  // Uncompressed CRC (unpopulated).
+  AppendInt32(&string_builder_, 0);
+  AppendString(&string_builder_, "");
+  AppendBytes(&string_builder_, chunk_records);
+  WriteRecord(OpCode::kChunk, string_builder_.Result());
+
+  std::map<uint16_t, uint64_t> index_offsets;
+  const uint64_t message_index_start = output_.tellp();
+  for (const auto &indices : message_indices_) {
+    index_offsets[indices.first] = output_.tellp();
+    string_builder_.Reset();
+    AppendInt16(&string_builder_, indices.first);
+    AppendMessageIndices(&string_builder_, indices.second);
+    WriteRecord(OpCode::kMessageIndex, string_builder_.Result());
+  }
+  message_indices_.clear();
+  chunk_indices_.push_back(ChunkIndex{
+      earliest_chunk_message_.value(), latest_message_, chunk_offset,
+      message_index_start - chunk_offset, records_size, index_offsets,
+      static_cast<uint64_t>(output_.tellp()) - message_index_start});
+  earliest_chunk_message_.reset();
+}
+
+McapLogger::SummaryOffset McapLogger::WriteStatistics() {
+  const uint64_t stats_offset = output_.tellp();
+  const uint64_t message_count = std::accumulate(
+      message_counts_.begin(), message_counts_.end(), 0,
+      [](const uint64_t &count, const std::pair<uint16_t, uint64_t> &val) {
+        return count + val.second;
+      });
+  string_builder_.Reset();
+  AppendInt64(&string_builder_, message_count);
+  // Schema count.
+  AppendInt16(&string_builder_, message_counts_.size());
+  // Channel count.
+  AppendInt32(&string_builder_, message_counts_.size());
+  // Attachment count.
+  AppendInt32(&string_builder_, 0);
+  // Metadata count.
+  AppendInt32(&string_builder_, 0);
+  // Chunk count.
+  AppendInt32(&string_builder_, chunk_indices_.size());
+  // Earliest & latest message times.
+  AppendInt64(&string_builder_, earliest_message_->time_since_epoch().count());
+  AppendInt64(&string_builder_, latest_message_.time_since_epoch().count());
+  // Per-channel message counts.
+  AppendChannelMap(&string_builder_, message_counts_);
+  WriteRecord(OpCode::kStatistics, string_builder_.Result());
+  return {OpCode::kStatistics, stats_offset,
+          static_cast<uint64_t>(output_.tellp()) - stats_offset};
+}
+
+McapLogger::SummaryOffset McapLogger::WriteChunkIndices() {
+  const uint64_t index_offset = output_.tellp();
+  for (const ChunkIndex &index : chunk_indices_) {
+    string_builder_.Reset();
+    AppendInt64(&string_builder_, index.start_time.time_since_epoch().count());
+    AppendInt64(&string_builder_, index.end_time.time_since_epoch().count());
+    AppendInt64(&string_builder_, index.offset);
+    AppendInt64(&string_builder_, index.chunk_size);
+    AppendChannelMap(&string_builder_, index.message_index_offsets);
+    AppendInt64(&string_builder_, index.message_index_size);
+    // Compression used.
+    AppendString(&string_builder_, "");
+    // Compressed and uncompressed records size.
+    AppendInt64(&string_builder_, index.records_size);
+    AppendInt64(&string_builder_, index.records_size);
+    WriteRecord(OpCode::kChunkIndex, string_builder_.Result());
+  }
+  return {OpCode::kChunkIndex, index_offset,
+          static_cast<uint64_t>(output_.tellp()) - index_offset};
+}
+
+void McapLogger::WriteSummaryOffset(const SummaryOffset &offset) {
+  string_builder_.Reset();
+  string_builder_.AppendChar(static_cast<char>(offset.op_code));
+  AppendInt64(&string_builder_, offset.offset);
+  AppendInt64(&string_builder_, offset.size);
+  WriteRecord(OpCode::kSummaryOffset, string_builder_.Result());
 }
 
 void McapLogger::AppendString(FastStringBuilder *builder,
@@ -210,14 +389,41 @@
   builder->Append(string);
 }
 
+void McapLogger::AppendBytes(FastStringBuilder *builder,
+                             std::string_view bytes) {
+  AppendInt64(builder, bytes.size());
+  builder->Append(bytes);
+}
+
 namespace {
 template <typename T>
 static void AppendInt(FastStringBuilder *builder, T val) {
   builder->Append(
       std::string_view(reinterpret_cast<const char *>(&val), sizeof(T)));
 }
+template <typename T>
+void AppendMap(FastStringBuilder *builder, const T &map) {
+  AppendInt<uint32_t>(
+      builder, map.size() * (sizeof(typename T::value_type::first_type) +
+                             sizeof(typename T::value_type::second_type)));
+  for (const auto &pair : map) {
+    AppendInt(builder, pair.first);
+    AppendInt(builder, pair.second);
+  }
+}
 }  // namespace
 
+void McapLogger::AppendChannelMap(FastStringBuilder *builder,
+                                  const std::map<uint16_t, uint64_t> &map) {
+  AppendMap(builder, map);
+}
+
+void McapLogger::AppendMessageIndices(
+    FastStringBuilder *builder,
+    const std::vector<std::pair<uint64_t, uint64_t>> &messages) {
+  AppendMap(builder, messages);
+}
+
 void McapLogger::AppendInt16(FastStringBuilder *builder, uint16_t val) {
   AppendInt(builder, val);
 }
diff --git a/aos/util/mcap_logger.h b/aos/util/mcap_logger.h
index 15d11db..dcacb68 100644
--- a/aos/util/mcap_logger.h
+++ b/aos/util/mcap_logger.h
@@ -26,6 +26,8 @@
 
 // Generates an MCAP file, per the specification at
 // https://github.com/foxglove/mcap/tree/main/docs/specification
+// This currently generates an uncompressed logfile with full message indexing
+// available, to be able to support Foxglove fully.
 class McapLogger {
  public:
   McapLogger(EventLoop *event_loop, const std::string &output_path);
@@ -38,30 +40,109 @@
     kSchema = 0x03,
     kChannel = 0x04,
     kMessage = 0x05,
+    kChunk = 0x06,
+    kMessageIndex = 0x07,
+    kChunkIndex = 0x08,
+    kAttachment = 0x09,
+    kAttachmentIndex = 0x0A,
+    kStatistics = 0x0B,
+    kMetadata = 0x0C,
+    kMetadataIndex = 0x0D,
+    kSummaryOffset = 0x0E,
     kDataEnd = 0x0F,
   };
+  // Stores information associated with a SummaryOffset entry (an offset to the
+  // start of a section within Summary section, which allows readers to quickly
+  // find all the indices/channel definitions/etc. for a given log).
+  struct SummaryOffset {
+    OpCode op_code;
+    // Offset from the start of the file.
+    uint64_t offset;
+    // Total length of the section, in bytes.
+    uint64_t size;
+  };
+  // Information needed to build a ChunkIndex entry.
+  struct ChunkIndex {
+    // Earliest and latest message times within the Chunk being referenced.
+    aos::monotonic_clock::time_point start_time;
+    aos::monotonic_clock::time_point end_time;
+    // Offset from the start of the file to the start of the relevant Chunk.
+    uint64_t offset;
+    // Total size of the Chunk, in bytes.
+    uint64_t chunk_size;
+    // Total size of the records portion of the Chunk, in bytes.
+    uint64_t records_size;
+    // Mapping of channel IDs to the MessageIndex entry for that channel within
+    // the referenced Chunk. The MessageIndex is referenced by an offset from
+    // the start of the file.
+    std::map<uint16_t, uint64_t> message_index_offsets;
+    // Total size, in bytes, of all the MessageIndex entries for this Chunk
+    // together (note that they are required to be contiguous).
+    uint64_t message_index_size;
+  };
+  enum class RegisterHandlers { kYes, kNo };
   // Helpers to write each type of relevant record.
   void WriteMagic();
   void WriteHeader();
-  void WriteFooter();
+  void WriteFooter(uint64_t summary_offset, uint64_t summary_offset_offset);
   void WriteDataEnd();
   void WriteSchema(const uint16_t id, const aos::Channel *channel);
   void WriteChannel(const uint16_t id, const uint16_t schema_id,
                     const aos::Channel *channel);
   void WriteMessage(uint16_t channel_id, const Channel *channel,
-                    const Context &context);
-  void WriteConfig();
+                    const Context &context, std::ostream *output);
+  void WriteChunk();
+
+  // The helpers for writing records which appear in the Summary section will
+  // return SummaryOffset's so that they can be referenced in the SummaryOffset
+  // section.
+  SummaryOffset WriteChunkIndices();
+  SummaryOffset WriteStatistics();
+  std::vector<SummaryOffset> WriteSchemasAndChannels(
+      RegisterHandlers register_handlers);
+  void WriteSummaryOffset(const SummaryOffset &offset);
 
   // Writes an MCAP record to the output file.
-  void WriteRecord(OpCode op, std::string_view record);
-  // Adds an MCAP-spec string/fixed-size integer to a buffer.
+  void WriteRecord(OpCode op, std::string_view record, std::ostream *ostream);
+  void WriteRecord(OpCode op, std::string_view record) {
+    WriteRecord(op, record, &output_);
+  }
+  // Adds an MCAP-spec string/byte-array/map/array of pairs/fixed-size integer
+  // to a buffer.
   static void AppendString(FastStringBuilder *builder, std::string_view string);
+  static void AppendBytes(FastStringBuilder *builder, std::string_view bytes);
+  static void AppendChannelMap(FastStringBuilder *builder,
+                               const std::map<uint16_t, uint64_t> &map);
+  static void AppendMessageIndices(
+      FastStringBuilder *builder,
+      const std::vector<std::pair<uint64_t, uint64_t>> &messages);
   static void AppendInt16(FastStringBuilder *builder, uint16_t val);
   static void AppendInt32(FastStringBuilder *builder, uint32_t val);
   static void AppendInt64(FastStringBuilder *builder, uint64_t val);
 
+  aos::EventLoop *event_loop_;
   std::ofstream output_;
+  // Buffer containing serialized message data for the currently-being-built
+  // chunk.
+  std::stringstream current_chunk_;
   FastStringBuilder string_builder_;
+
+  // Earliest message observed in this logfile.
+  std::optional<aos::monotonic_clock::time_point> earliest_message_;
+  // Earliest message observed in the current chunk.
+  std::optional<aos::monotonic_clock::time_point> earliest_chunk_message_;
+  // Latest message observed.
+  aos::monotonic_clock::time_point latest_message_ =
+      aos::monotonic_clock::min_time;
+  // Count of all messages on each channel, indexed by channel ID.
+  std::map<uint16_t, uint64_t> message_counts_;
+  // MessageIndex's for each message. The std::map is indexed by channel ID. The
+  // vector is then a series of pairs of (timestamp, offset from start of
+  // current_chunk_).
+  std::map<uint16_t, std::vector<std::pair<uint64_t, uint64_t>>>
+      message_indices_;
+  // ChunkIndex's for all fully written Chunks.
+  std::vector<ChunkIndex> chunk_indices_;
 };
 }  // namespace aos
 #endif  // AOS_UTIL_MCAP_LOGGER_H_
diff --git a/aos/util/process_info.fbs b/aos/util/process_info.fbs
new file mode 100644
index 0000000..aafdba3
--- /dev/null
+++ b/aos/util/process_info.fbs
@@ -0,0 +1,23 @@
+namespace aos.util;
+
+// ProcessInfo captures state information associated with a given process.
+table ProcessInfo {
+  // Process ID of the process in question.
+  pid: uint (id: 0);
+  // Name of the running executable.
+  name: string (id: 1);
+  // Time that the process spent executing over the past ~1 second, divided by
+  // the amount of wall-clock time that elapsed in that period. I.e., if a process is
+  // consuming all of one CPU core then this would be 1.0. Multi-threaded processes
+  // can exceed 1.0.
+  cpu_usage: float (id: 2);
+  // Amount of physical RAM taken by this process, in bytes. Will be a multiple of the
+  // system's page size.
+  physical_memory: uint64 (id: 3);
+}
+
+table TopProcessesFbs {
+  // List of processes consuming the most CPU in the last sample period, in order from
+  // most CPU to least.
+  processes: [ProcessInfo] (id: 0);
+}
diff --git a/aos/util/top.cc b/aos/util/top.cc
new file mode 100644
index 0000000..8a0019d
--- /dev/null
+++ b/aos/util/top.cc
@@ -0,0 +1,259 @@
+#include "aos/util/top.h"
+
+#include <dirent.h>
+#include <unistd.h>
+
+#include <queue>
+#include <string>
+
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_split.h"
+
+namespace aos::util {
+namespace {
+std::optional<std::string> ReadShortFile(std::string_view file_name) {
+  // Open as input and seek to end immediately.
+  std::ifstream file(std::string(file_name), std::ios_base::in);
+  if (!file.good()) {
+    VLOG(1) << "Can't read " << file_name;
+    return std::nullopt;
+  }
+  const size_t kMaxLineLength = 4096;
+  char buffer[kMaxLineLength];
+  file.read(buffer, kMaxLineLength);
+  if (!file.eof()) {
+    return std::nullopt;
+  }
+  return std::string(buffer, file.gcount());
+}
+}  // namespace
+
+std::optional<ProcStat> ReadProcStat(pid_t pid) {
+  std::optional<std::string> contents =
+      ReadShortFile(absl::StrFormat("/proc/%d/stat", pid));
+  if (!contents.has_value()) {
+    return std::nullopt;
+  }
+  const size_t start_name = contents->find_first_of('(');
+  const size_t end_name = contents->find_last_of(')');
+  if (start_name == std::string::npos || end_name == std::string::npos ||
+      end_name < start_name) {
+    VLOG(1) << "No name found in stat line " << contents.value();
+    return std::nullopt;
+  }
+  std::string_view name(contents->c_str() + start_name + 1,
+                        end_name - start_name - 1);
+
+  std::vector<std::string_view> fields =
+      absl::StrSplit(std::string_view(contents->c_str() + end_name + 1,
+                                      contents->size() - end_name - 1),
+                     ' ', absl::SkipWhitespace());
+  constexpr int kNumFieldsAfterName = 50;
+  if (fields.size() != kNumFieldsAfterName) {
+    VLOG(1) << "Incorrect number of fields " << fields.size();
+    return std::nullopt;
+  }
+  // The first field is a character for the current process state; every single
+  // field after that should be an integer.
+  if (fields[0].size() != 1) {
+    VLOG(1) << "State field is too long: " << fields[0];
+    return std::nullopt;
+  }
+  std::array<absl::int128, kNumFieldsAfterName - 1> numbers;
+  for (int ii = 1; ii < kNumFieldsAfterName; ++ii) {
+    if (!absl::SimpleAtoi(fields[ii], &numbers[ii - 1])) {
+      VLOG(1) << "Failed to parse field " << ii << " as number: " << fields[ii];
+      return std::nullopt;
+    }
+  }
+  return ProcStat{
+      .pid = pid,
+      .name = std::string(name),
+      .state = fields.at(0).at(0),
+      .parent_pid = static_cast<int64_t>(numbers.at(0)),
+      .group_id = static_cast<int64_t>(numbers.at(1)),
+      .session_id = static_cast<int64_t>(numbers.at(2)),
+      .tty = static_cast<int64_t>(numbers.at(3)),
+      .tpgid = static_cast<int64_t>(numbers.at(4)),
+      .kernel_flags = static_cast<uint64_t>(numbers.at(5)),
+      .minor_faults = static_cast<uint64_t>(numbers.at(6)),
+      .children_minor_faults = static_cast<uint64_t>(numbers.at(7)),
+      .major_faults = static_cast<uint64_t>(numbers.at(8)),
+      .children_major_faults = static_cast<uint64_t>(numbers.at(9)),
+      .user_mode_ticks = static_cast<uint64_t>(numbers.at(10)),
+      .kernel_mode_ticks = static_cast<uint64_t>(numbers.at(11)),
+      .children_user_mode_ticks = static_cast<int64_t>(numbers.at(12)),
+      .children_kernel_mode_ticks = static_cast<int64_t>(numbers.at(13)),
+      .priority = static_cast<int64_t>(numbers.at(14)),
+      .nice = static_cast<int64_t>(numbers.at(15)),
+      .num_threads = static_cast<int64_t>(numbers.at(16)),
+      .itrealvalue = static_cast<int64_t>(numbers.at(17)),
+      .start_time_ticks = static_cast<uint64_t>(numbers.at(18)),
+      .virtual_memory_size = static_cast<uint64_t>(numbers.at(19)),
+      .resident_set_size = static_cast<int64_t>(numbers.at(20)),
+      .rss_soft_limit = static_cast<uint64_t>(numbers.at(21)),
+      .start_code_address = static_cast<uint64_t>(numbers.at(22)),
+      .end_code_address = static_cast<uint64_t>(numbers.at(23)),
+      .start_stack_address = static_cast<uint64_t>(numbers.at(24)),
+      .stack_pointer = static_cast<uint64_t>(numbers.at(25)),
+      .instruction_pointer = static_cast<uint64_t>(numbers.at(26)),
+      .signal_bitmask = static_cast<uint64_t>(numbers.at(27)),
+      .blocked_signals = static_cast<uint64_t>(numbers.at(28)),
+      .ignored_signals = static_cast<uint64_t>(numbers.at(29)),
+      .caught_signals = static_cast<uint64_t>(numbers.at(30)),
+      .wchan = static_cast<uint64_t>(numbers.at(31)),
+      .swap_pages = static_cast<uint64_t>(numbers.at(32)),
+      .children_swap_pages = static_cast<uint64_t>(numbers.at(33)),
+      .exit_signal = static_cast<int64_t>(numbers.at(34)),
+      .processor = static_cast<int64_t>(numbers.at(35)),
+      .rt_priority = static_cast<uint64_t>(numbers.at(36)),
+      .scheduling_policy = static_cast<uint64_t>(numbers.at(37)),
+      .block_io_delay_ticks = static_cast<uint64_t>(numbers.at(38)),
+      .guest_ticks = static_cast<uint64_t>(numbers.at(39)),
+      .children_guest_ticks = static_cast<uint64_t>(numbers.at(40)),
+      .start_data_address = static_cast<uint64_t>(numbers.at(41)),
+      .end_data_address = static_cast<uint64_t>(numbers.at(42)),
+      .start_brk_address = static_cast<uint64_t>(numbers.at(43)),
+      .start_arg_address = static_cast<uint64_t>(numbers.at(44)),
+      .end_arg_address = static_cast<uint64_t>(numbers.at(45)),
+      .start_env_address = static_cast<uint64_t>(numbers.at(46)),
+      .end_env_address = static_cast<uint64_t>(numbers.at(47)),
+      .exit_code = static_cast<int64_t>(numbers.at(48))};
+}
+
+Top::Top(aos::EventLoop *event_loop)
+    : event_loop_(event_loop),
+      clock_tick_(std::chrono::nanoseconds(1000000000 / sysconf(_SC_CLK_TCK))),
+      page_size_(sysconf(_SC_PAGESIZE)) {
+  TimerHandler *timer = event_loop_->AddTimer([this]() { UpdateReadings(); });
+  event_loop_->OnRun([timer, this]() {
+    timer->Setup(event_loop_->monotonic_now(), kSamplePeriod);
+  });
+}
+
+std::chrono::nanoseconds Top::TotalProcessTime(const ProcStat &proc_stat) {
+  return (proc_stat.user_mode_ticks + proc_stat.kernel_mode_ticks) *
+         clock_tick_;
+}
+
+aos::monotonic_clock::time_point Top::ProcessStartTime(
+    const ProcStat &proc_stat) {
+  return aos::monotonic_clock::time_point(proc_stat.start_time_ticks *
+                                          clock_tick_);
+}
+
+uint64_t Top::RealMemoryUsage(const ProcStat &proc_stat) {
+  return proc_stat.resident_set_size * page_size_;
+}
+
+void Top::UpdateReadings() {
+  aos::monotonic_clock::time_point now = event_loop_->monotonic_now();
+  // Get all the processes that we *might* care about.
+  std::set<pid_t> pids = pids_to_track_;
+  if (track_all_) {
+    DIR *const dir = opendir("/proc");
+    if (dir == nullptr) {
+      PLOG(FATAL) << "Failed to open /proc";
+    }
+    while (true) {
+      struct dirent *const dir_entry = readdir(dir);
+      if (dir_entry == nullptr) {
+        break;
+      }
+      pid_t pid;
+      if (dir_entry->d_type == DT_DIR &&
+          absl::SimpleAtoi(dir_entry->d_name, &pid)) {
+        pids.insert(pid);
+      }
+    }
+  }
+
+  for (const pid_t pid : pids) {
+    std::optional<ProcStat> proc_stat = ReadProcStat(pid);
+    // Stop tracking processes that have died.
+    if (!proc_stat.has_value()) {
+      readings_.erase(pid);
+      continue;
+    }
+    const aos::monotonic_clock::time_point start_time =
+        ProcessStartTime(*proc_stat);
+    auto reading_iter = readings_.find(pid);
+    if (reading_iter == readings_.end()) {
+      reading_iter = readings_
+                         .insert(std::make_pair(
+                             pid, ProcessReadings{.name = proc_stat->name,
+                                                  .start_time = start_time,
+                                                  .cpu_percent = 0.0,
+                                                  .readings = {}}))
+                         .first;
+    }
+    ProcessReadings &process = reading_iter->second;
+    // The process associated with the PID has changed; reset the state.
+    if (process.start_time != start_time) {
+      process.name = proc_stat->name;
+      process.start_time = start_time;
+      process.readings.Reset();
+    }
+    // If the process name has changed (e.g., if our first reading for a process
+    // name occurred before execvp was called), then update it.
+    if (process.name != proc_stat->name) {
+      process.name = proc_stat->name;
+    }
+
+    process.readings.Push(Reading{now, TotalProcessTime(*proc_stat),
+                                  RealMemoryUsage(*proc_stat)});
+    if (process.readings.size() == 2) {
+      process.cpu_percent =
+          aos::time::DurationInSeconds(process.readings[1].total_run_time -
+                                       process.readings[0].total_run_time) /
+          aos::time::DurationInSeconds(process.readings[1].reading_time -
+                                       process.readings[0].reading_time);
+    } else {
+      process.cpu_percent = 0.0;
+    }
+  }
+}
+
+flatbuffers::Offset<ProcessInfo> Top::InfoForProcess(
+    flatbuffers::FlatBufferBuilder *fbb, pid_t pid) {
+  auto reading_iter = readings_.find(pid);
+  if (reading_iter == readings_.end()) {
+    return {};
+  }
+  const ProcessReadings &reading = reading_iter->second;
+  const flatbuffers::Offset<flatbuffers::String> name =
+      fbb->CreateString(reading.name);
+  ProcessInfo::Builder builder(*fbb);
+  builder.add_pid(pid);
+  builder.add_name(name);
+  builder.add_cpu_usage(reading.cpu_percent);
+  builder.add_physical_memory(
+      reading.readings[reading.readings.size() - 1].memory_usage);
+  return builder.Finish();
+}
+
+flatbuffers::Offset<TopProcessesFbs> Top::TopProcesses(
+    flatbuffers::FlatBufferBuilder *fbb, int n) {
+  // Pair is {cpu_usage, pid}.
+  std::priority_queue<std::pair<double, pid_t>> cpu_usages;
+  for (const auto &pair : readings_) {
+    // Deliberately include 0.0 percent CPU things in the usage list so that if
+    // the user asks for an arbitrarily large number of processes they'll get
+    // everything.
+    cpu_usages.push(std::make_pair(pair.second.cpu_percent, pair.first));
+  }
+  std::vector<flatbuffers::Offset<ProcessInfo>> offsets;
+  for (int ii = 0; ii < n && !cpu_usages.empty(); ++ii) {
+    offsets.push_back(InfoForProcess(fbb, cpu_usages.top().second));
+    cpu_usages.pop();
+  }
+  const flatbuffers::Offset<
+      flatbuffers::Vector<flatbuffers::Offset<ProcessInfo>>>
+      vector_offset = fbb->CreateVector(offsets);
+  TopProcessesFbs::Builder builder(*fbb);
+  builder.add_processes(vector_offset);
+  return builder.Finish();
+}
+
+}  // namespace aos::util
diff --git a/aos/util/top.h b/aos/util/top.h
new file mode 100644
index 0000000..32ff65d
--- /dev/null
+++ b/aos/util/top.h
@@ -0,0 +1,157 @@
+#ifndef AOS_UTIL_TOP_H_
+#define AOS_UTIL_TOP_H_
+
+#include <map>
+#include <string>
+
+#include "aos/containers/ring_buffer.h"
+#include "aos/events/event_loop.h"
+#include "aos/util/process_info_generated.h"
+
+namespace aos::util {
+
+// ProcStat is a struct to hold all the fields available in /proc/[pid]/stat.
+// Currently we only use a small subset of the feilds. See man 5 proc for
+// details on what the fields are--these are in the same order as they appear in
+// the stat file.
+//
+// Things are signed or unsigned based on whether they are listed
+// as signed/unsigned in man 5 proc. We just make everything 64 bits wide
+// because otherwise we have to write out way too many casts everywhere.
+struct ProcStat {
+  int pid;
+  std::string name;
+  char state;
+  int64_t parent_pid;
+  int64_t group_id;
+  int64_t session_id;
+  int64_t tty;
+  int64_t tpgid;
+  uint64_t kernel_flags;
+  uint64_t minor_faults;
+  uint64_t children_minor_faults;
+  uint64_t major_faults;
+  uint64_t children_major_faults;
+  uint64_t user_mode_ticks;
+  uint64_t kernel_mode_ticks;
+  int64_t children_user_mode_ticks;
+  int64_t children_kernel_mode_ticks;
+  int64_t priority;
+  int64_t nice;
+  int64_t num_threads;
+  int64_t itrealvalue;  // always zero.
+  uint64_t start_time_ticks;
+  uint64_t virtual_memory_size;
+  // Number of pages in real memory.
+  int64_t resident_set_size;
+  uint64_t rss_soft_limit;
+  uint64_t start_code_address;
+  uint64_t end_code_address;
+  uint64_t start_stack_address;
+  uint64_t stack_pointer;
+  uint64_t instruction_pointer;
+  uint64_t signal_bitmask;
+  uint64_t blocked_signals;
+  uint64_t ignored_signals;
+  uint64_t caught_signals;
+  uint64_t wchan;
+  // swap_pages fields are not maintained.
+  uint64_t swap_pages;
+  uint64_t children_swap_pages;
+  int64_t exit_signal;
+  // CPU number last exitted on.
+  int64_t processor;
+  // Zero for non-realtime processes.
+  uint64_t rt_priority;
+  uint64_t scheduling_policy;
+  // Aggregated block I/O delay.
+  uint64_t block_io_delay_ticks;
+  uint64_t guest_ticks;
+  uint64_t children_guest_ticks;
+  uint64_t start_data_address;
+  uint64_t end_data_address;
+  uint64_t start_brk_address;
+  uint64_t start_arg_address;
+  uint64_t end_arg_address;
+  uint64_t start_env_address;
+  uint64_t end_env_address;
+  int64_t exit_code;
+};
+
+// Retrieves the stats for a particular process (note that there also exists a
+// /proc/[pid]/task/[tid]/stat with the same format for per-thread information;
+// we currently do not read that).
+// Returns nullopt if unable to read/parse the file.
+std::optional<ProcStat> ReadProcStat(int pid);
+
+// This class provides a basic utility for retrieving general performance
+// information on running processes (named after the top utility). It can either
+// be used to directly get information on individual processes (via
+// set_track_pids()) or used to track a list of the top N processes with the
+// highest CPU usage.
+// Note that this currently relies on sampling processes in /proc every second
+// and using the differences between the two readings to calculate CPU usage.
+// For crash-looping processees or other situations with highly variable or
+// extremely short-lived loads, this may do a poor job of capturing information.
+class Top {
+ public:
+  Top(aos::EventLoop *event_loop);
+
+  // Set whether to track all the top processes (this will result in us having
+  // to track every single process on the system, so that we can sort them).
+  void set_track_top_processes(bool track_all) { track_all_ = track_all; }
+
+  // Specify a set of individual processes to track statistics for.
+  // This can be changed at run-time, although it may take up to kSamplePeriod
+  // to have full statistics on all the relevant processes, since we need at
+  // least two samples to estimate CPU usage.
+  void set_track_pids(const std::set<pid_t> &pids) { pids_to_track_ = pids; }
+
+  // Retrieve statistics for the specified process. Will return the null offset
+  // of no such pid is being tracked.
+  flatbuffers::Offset<ProcessInfo> InfoForProcess(
+      flatbuffers::FlatBufferBuilder *fbb, pid_t pid);
+
+  // Returns information on up to n processes, sorted by CPU usage.
+  flatbuffers::Offset<TopProcessesFbs> TopProcesses(
+      flatbuffers::FlatBufferBuilder *fbb, int n);
+
+ private:
+  // Rate at which to sample /proc/[pid]/stat.
+  static constexpr std::chrono::seconds kSamplePeriod{1};
+
+  struct Reading {
+    aos::monotonic_clock::time_point reading_time;
+    std::chrono::nanoseconds total_run_time;
+    uint64_t memory_usage;
+  };
+
+  struct ProcessReadings {
+    std::string name;
+    aos::monotonic_clock::time_point start_time;
+    // CPU usage is based on the past two readings.
+    double cpu_percent;
+    aos::RingBuffer<Reading, 2> readings;
+  };
+
+  std::chrono::nanoseconds TotalProcessTime(const ProcStat &proc_stat);
+  aos::monotonic_clock::time_point ProcessStartTime(const ProcStat &proc_stat);
+  uint64_t RealMemoryUsage(const ProcStat &proc_stat);
+  void UpdateReadings();
+
+  aos::EventLoop *event_loop_;
+
+  // Length of a clock tick (used to convert from raw numbers in /proc to actual
+  // times).
+  const std::chrono::nanoseconds clock_tick_;
+  // Page size, in bytes, on the current system.
+  const long page_size_;
+
+  std::set<pid_t> pids_to_track_;
+  bool track_all_ = false;
+
+  std::map<pid_t, ProcessReadings> readings_;
+};
+
+}  // namespace aos::util
+#endif  // AOS_UTIL_TOP_H_
diff --git a/aos/util/top_test.cc b/aos/util/top_test.cc
new file mode 100644
index 0000000..36afd64
--- /dev/null
+++ b/aos/util/top_test.cc
@@ -0,0 +1,180 @@
+#include "aos/util/top.h"
+
+#include <unistd.h>
+
+#include <array>
+#include <string>
+#include <thread>
+
+#include "aos/events/shm_event_loop.h"
+#include "aos/json_to_flatbuffer.h"
+#include "aos/testing/path.h"
+#include "aos/testing/tmpdir.h"
+#include "gtest/gtest.h"
+
+namespace aos::util::testing {
+
+class TopTest : public ::testing::Test {
+ protected:
+  TopTest()
+      : shm_dir_(aos::testing::TestTmpDir() + "/aos"),
+        cpu_consumer_([this]() {
+          while (!stop_flag_.load()) {
+          }
+        }),
+        config_file_(
+            aos::testing::ArtifactPath("aos/events/pingpong_config.json")),
+        config_(aos::configuration::ReadConfig(config_file_)),
+        event_loop_(&config_.message()) {
+    FLAGS_shm_base = shm_dir_;
+
+    // Nuke the shm dir, to ensure we aren't being affected by any preexisting tests.
+    aos::util::UnlinkRecursive(shm_dir_);
+  }
+  ~TopTest() {
+    stop_flag_ = true;
+    cpu_consumer_.join();
+  }
+
+  gflags::FlagSaver flag_saver_;
+  std::string shm_dir_;
+
+  std::thread cpu_consumer_;
+  std::atomic<bool> stop_flag_{false};
+  const std::string config_file_;
+  const aos::FlatbufferDetachedBuffer<aos::Configuration> config_;
+  aos::ShmEventLoop event_loop_;
+};
+
+TEST_F(TopTest, TestSelfStat) {
+  const pid_t pid = getpid();
+  std::optional<ProcStat> proc_stat = ReadProcStat(pid);
+  ASSERT_TRUE(proc_stat.has_value());
+  ASSERT_EQ(pid, proc_stat->pid);
+  ASSERT_EQ("top_test", proc_stat->name);
+  ASSERT_EQ('R', proc_stat->state);
+  ASSERT_LT(1, proc_stat->num_threads);
+}
+
+TEST_F(TopTest, QuerySingleProcess) {
+  const pid_t pid = getpid();
+  Top top(&event_loop_);
+  top.set_track_pids({pid});
+  event_loop_.AddTimer([this]() { event_loop_.Exit(); })
+      ->Setup(event_loop_.monotonic_now() + std::chrono::seconds(2));
+  event_loop_.Run();
+  flatbuffers::FlatBufferBuilder fbb;
+  fbb.ForceDefaults(true);
+  fbb.Finish(top.InfoForProcess(&fbb, pid));
+  aos::FlatbufferDetachedBuffer<ProcessInfo> info = fbb.Release();
+  ASSERT_EQ(pid, info.message().pid());
+  ASSERT_TRUE(info.message().has_name());
+  ASSERT_EQ("top_test", info.message().name()->string_view());
+  // Check that we did indeed consume ~1 CPU core (because we're multi-threaded,
+  // we could've consumed a bit more; and on systems where we are competing with
+  // other processes for CPU time, we may not get a full 100% load).
+  ASSERT_LT(0.5, info.message().cpu_usage());
+  ASSERT_GT(1.1, info.message().cpu_usage());
+  // Sanity check memory usage.
+  ASSERT_LT(1000000, info.message().physical_memory());
+  ASSERT_GT(1000000000, info.message().physical_memory());
+}
+
+TEST_F(TopTest, TopProcesses) {
+  // Make some dummy processes that will just spin and get killed off at the
+  // end, so that we actually have things to query.
+  constexpr int kNProcesses = 2;
+  std::vector<pid_t> children;
+  // This will create kNProcesses children + ourself, which means we have enough
+  // processes to test that we correctly exclude extras when requesting fewer
+  // processes than exist.
+  for (int ii = 0; ii < kNProcesses; ++ii) {
+    const pid_t pid = fork();
+    PCHECK(pid >= 0);
+    if (pid == 0) {
+      LOG(INFO) << "In child process.";
+      while (true) {
+        // This is a "please don't optimize me out" thing for the compiler.
+        // Otherwise, the entire if (pid == 0) block can get optimized away...
+        asm("");
+        continue;
+      }
+      LOG(FATAL) << "This should be unreachable.";
+    } else {
+      CHECK_NE(0, pid) << "The compiler is messing with you.";
+      children.push_back(pid);
+    }
+  }
+
+  Top top(&event_loop_);
+  top.set_track_top_processes(true);
+  event_loop_.AddTimer([this]() { event_loop_.Exit(); })
+      ->Setup(event_loop_.monotonic_now() + std::chrono::seconds(2));
+  event_loop_.SkipTimingReport();
+  event_loop_.SkipAosLog();
+  event_loop_.Run();
+  flatbuffers::FlatBufferBuilder fbb;
+  fbb.ForceDefaults(true);
+  fbb.Finish(top.TopProcesses(&fbb, kNProcesses));
+  aos::FlatbufferDetachedBuffer<TopProcessesFbs> info = fbb.Release();
+  ASSERT_EQ(kNProcesses, info.message().processes()->size());
+  double last_cpu = std::numeric_limits<double>::infinity();
+  std::set<pid_t> observed_pids;
+  int process_index = 0;
+  for (const ProcessInfo *info : *info.message().processes()) {
+    SCOPED_TRACE(aos::FlatbufferToJson(info));
+    ASSERT_EQ(0, observed_pids.count(info->pid()));
+    observed_pids.insert(info->pid());
+    ASSERT_TRUE(info->has_name());
+    // Confirm that the top process has non-zero CPU usage, but allow the
+    // lower-down processes to have not been scheduled in the last measurement
+    // cycle.
+    if (process_index < 1) {
+      ASSERT_LT(0.0, info->cpu_usage());
+    } else {
+      ASSERT_LE(0.0, info->cpu_usage());
+    }
+    ++process_index;
+    ASSERT_GE(last_cpu, info->cpu_usage());
+    last_cpu = info->cpu_usage();
+    ASSERT_LT(0, info->physical_memory());
+  }
+
+  for (const pid_t child : children) {
+    kill(child, SIGINT);
+  }
+}
+
+// Test thgat if we request arbitrarily many processes that we only get back as
+// many processes as actually exist and that nothing breaks.
+TEST_F(TopTest, AllTopProcesses) {
+  constexpr int kNProcesses = 1000000;
+
+  Top top(&event_loop_);
+  top.set_track_top_processes(true);
+  event_loop_.AddTimer([this]() { event_loop_.Exit(); })
+      ->Setup(event_loop_.monotonic_now() + std::chrono::seconds(2));
+  event_loop_.Run();
+  flatbuffers::FlatBufferBuilder fbb;
+  fbb.ForceDefaults(true);
+  // There should only be at most 2-3 processes visible inside the bazel
+  // sandbox.
+  fbb.Finish(top.TopProcesses(&fbb, kNProcesses));
+  aos::FlatbufferDetachedBuffer<TopProcessesFbs> info = fbb.Release();
+  ASSERT_GT(kNProcesses, info.message().processes()->size());
+  double last_cpu = std::numeric_limits<double>::infinity();
+  std::set<pid_t> observed_pids;
+  for (const ProcessInfo *info : *info.message().processes()) {
+    SCOPED_TRACE(aos::FlatbufferToJson(info));
+    LOG(INFO) << aos::FlatbufferToJson(info);
+    ASSERT_EQ(0, observed_pids.count(info->pid()));
+    observed_pids.insert(info->pid());
+    ASSERT_TRUE(info->has_name());
+    ASSERT_LE(0.0, info->cpu_usage());
+    ASSERT_GE(last_cpu, info->cpu_usage());
+    last_cpu = info->cpu_usage();
+    ASSERT_LE(0, info->physical_memory());
+  }
+}
+
+}  // namespace aos::util::testing
diff --git a/build_tests/BUILD b/build_tests/BUILD
index 705c4ff..29a1275 100644
--- a/build_tests/BUILD
+++ b/build_tests/BUILD
@@ -146,9 +146,8 @@
 
 rust_test(
     name = "hello_lib_test",
-    srcs = ["hello_lib.rs"],
+    crate = ":hello_lib",
     target_compatible_with = ["@platforms//os:linux"],
-    deps = [":hello_lib"],
 )
 
 rust_binary(
diff --git a/debian/BUILD b/debian/BUILD
index 3088cf4..c920457 100644
--- a/debian/BUILD
+++ b/debian/BUILD
@@ -71,6 +71,10 @@
     gstreamer_armhf_debs = "files",
 )
 load(
+    ":gstreamer_arm64.bzl",
+    gstreamer_arm64_debs = "files",
+)
+load(
     ":lzma_amd64.bzl",
     lzma_amd64_debs = "files",
 )
@@ -460,6 +464,12 @@
     target_compatible_with = ["@platforms//os:linux"],
 )
 
+generate_deb_tarball(
+    name = "gstreamer_arm64",
+    files = gstreamer_arm64_debs,
+    target_compatible_with = ["@platforms//os:linux"],
+)
+
 download_packages(
     name = "download_lzma",
     packages = [
diff --git a/debian/gstreamer.BUILD b/debian/gstreamer.BUILD
index b203772..8b58634 100644
--- a/debian/gstreamer.BUILD
+++ b/debian/gstreamer.BUILD
@@ -1,85 +1,233 @@
 load("@//tools/build_rules:select.bzl", "cpu_select")
 
+_common_srcs_list = [
+    "lib/%s/libcap.so.2",
+    "lib/%s/libdbus-1.so.3",
+    "lib/%s/libexpat.so.1",
+    "lib/%s/libgpg-error.so.0",
+    "lib/%s/libpcre.so.3",
+    "usr/lib/%s/blas/libblas.so.3",
+    "usr/lib/%s/gstreamer-1.0/libgstapp.so",
+    "usr/lib/%s/gstreamer-1.0/libgstcoreelements.so",
+    "usr/lib/%s/gstreamer-1.0/libgstdtls.so",
+    "usr/lib/%s/gstreamer-1.0/libgstnice.so",
+    "usr/lib/%s/gstreamer-1.0/libgstrtp.so",
+    "usr/lib/%s/gstreamer-1.0/libgstrtpmanager.so",
+    "usr/lib/%s/gstreamer-1.0/libgstsrtp.so",
+    "usr/lib/%s/gstreamer-1.0/libgstv4l2codecs.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideo4linux2.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideoconvert.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideoparsersbad.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideorate.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideoscale.so",
+    "usr/lib/%s/gstreamer-1.0/libgstvideotestsrc.so",
+    "usr/lib/%s/gstreamer-1.0/libgstwebrtc.so",
+    "usr/lib/%s/gstreamer-1.0/libgstx264.so",
+    "usr/lib/%s/lapack/liblapack.so.3",
+    "usr/lib/%s/libEGL.so.1",
+    "usr/lib/%s/libGL.so.1",
+    "usr/lib/%s/libGLX.so.0",
+    "usr/lib/%s/libGLdispatch.so.0",
+    "usr/lib/%s/libHalf-2_5.so.25",
+    "usr/lib/%s/libIex-2_5.so.25",
+    "usr/lib/%s/libIlmImf-2_5.so.25",
+    "usr/lib/%s/libIlmThread-2_5.so.25",
+    "usr/lib/%s/libImath-2_5.so.25",
+    "usr/lib/%s/libX11-xcb.so.1",
+    "usr/lib/%s/libX11.so.6",
+    "usr/lib/%s/libXau.so.6",
+    "usr/lib/%s/libXcomposite.so.1",
+    "usr/lib/%s/libXcursor.so.1",
+    "usr/lib/%s/libXdamage.so.1",
+    "usr/lib/%s/libXdmcp.so.6",
+    "usr/lib/%s/libXext.so.6",
+    "usr/lib/%s/libXfixes.so.3",
+    "usr/lib/%s/libXi.so.6",
+    "usr/lib/%s/libXinerama.so.1",
+    "usr/lib/%s/libXrandr.so.2",
+    "usr/lib/%s/libXrender.so.1",
+    "usr/lib/%s/libaec.so.0",
+    "usr/lib/%s/libaom.so.0",
+    "usr/lib/%s/libarpack.so.2",
+    "usr/lib/%s/libatk-1.0.so.0",
+    "usr/lib/%s/libatk-bridge-2.0.so.0",
+    "usr/lib/%s/libatspi.so.0",
+    "usr/lib/%s/libblkid.so.1",
+    "usr/lib/%s/libbrotlicommon.so.1",
+    "usr/lib/%s/libbrotlidec.so.1",
+    "usr/lib/%s/libbsd.so.0",
+    "usr/lib/%s/libcairo-gobject.so.2",
+    "usr/lib/%s/libcairo.so.2",
+    "usr/lib/%s/libcfitsio.so.9",
+    "usr/lib/%s/libcharls.so.2",
+    "usr/lib/%s/libcurl-gnutls.so.4",
+    "usr/lib/%s/libcurl.so.4",
+    "usr/lib/%s/libdap.so.27",
+    "usr/lib/%s/libdapclient.so.6",
+    "usr/lib/%s/libdatrie.so.1",
+    "usr/lib/%s/libdav1d.so.4",
+    "usr/lib/%s/libde265.so.0",
+    "usr/lib/%s/libdeflate.so.0",
+    "usr/lib/%s/libdrm.so.2",
+    "usr/lib/%s/libdw.so.1",
+    "usr/lib/%s/libelf.so.1",
+    "usr/lib/%s/libepoxy.so.0",
+    "usr/lib/%s/libepsilon.so.1",
+    "usr/lib/%s/libffi.so.7",
+    "usr/lib/%s/libfontconfig.so.1",
+    "usr/lib/%s/libfreetype.so.6",
+    "usr/lib/%s/libfreexl.so.1",
+    "usr/lib/%s/libfribidi.so.0",
+    "usr/lib/%s/libfyba.so.0",
+    "usr/lib/%s/libfygm.so.0",
+    "usr/lib/%s/libfyut.so.0",
+    "usr/lib/%s/libgbm.so.1",
+    "usr/lib/%s/libgcrypt.so.20",
+    "usr/lib/%s/libgdcmCommon.so.3.0",
+    "usr/lib/%s/libgdcmDICT.so.3.0",
+    "usr/lib/%s/libgdcmDSED.so.3.0",
+    "usr/lib/%s/libgdcmIOD.so.3.0",
+    "usr/lib/%s/libgdcmMSFF.so.3.0",
+    "usr/lib/%s/libgdcmjpeg12.so.3.0",
+    "usr/lib/%s/libgdcmjpeg16.so.3.0",
+    "usr/lib/%s/libgdcmjpeg8.so.3.0",
+    "usr/lib/%s/libgdk-3.so.0",
+    "usr/lib/%s/libgdk_pixbuf-2.0.so.0",
+    "usr/lib/%s/libgeos-3.9.0.so",
+    "usr/lib/%s/libgeos_c.so.1",
+    "usr/lib/%s/libgeotiff.so.5",
+    "usr/lib/%s/libgfortran.so.5",
+    "usr/lib/%s/libgif.so.7",
+    "usr/lib/%s/libgio-2.0.so.0",
+    "usr/lib/%s/libglib-2.0.so.0",
+    "usr/lib/%s/libgmodule-2.0.so.0",
+    "usr/lib/%s/libgmp.so.10",
+    "usr/lib/%s/libgnutls.so.30",
+    "usr/lib/%s/libgobject-2.0.so.0",
+    "usr/lib/%s/libgraphite2.so.3",
+    "usr/lib/%s/libgssdp-1.2.so.0",
+    "usr/lib/%s/libgstallocators-1.0.so.0",
+    "usr/lib/%s/libgstapp-1.0.so.0",
+    "usr/lib/%s/libgstaudio-1.0.so.0",
+    "usr/lib/%s/libgstbase-1.0.so.0",
+    "usr/lib/%s/libgstcodecparsers-1.0.so.0",
+    "usr/lib/%s/libgstcodecs-1.0.so.0",
+    "usr/lib/%s/libgstgl-1.0.so.0",
+    "usr/lib/%s/libgstnet-1.0.so.0",
+    "usr/lib/%s/libgstpbutils-1.0.so.0",
+    "usr/lib/%s/libgstreamer-1.0.so.0",
+    "usr/lib/%s/libgstrtp-1.0.so.0",
+    "usr/lib/%s/libgstsctp-1.0.so.0",
+    "usr/lib/%s/libgstsdp-1.0.so.0",
+    "usr/lib/%s/libgsttag-1.0.so.0",
+    "usr/lib/%s/libgstvideo-1.0.so.0",
+    "usr/lib/%s/libgstwebrtc-1.0.so.0",
+    "usr/lib/%s/libgthread-2.0.so.0",
+    "usr/lib/%s/libgtk-3.so.0",
+    "usr/lib/%s/libgudev-1.0.so.0",
+    "usr/lib/%s/libgupnp-1.2.so.0",
+    "usr/lib/%s/libgupnp-igd-1.0.so.4",
+    "usr/lib/%s/libharfbuzz.so.0",
+    "usr/lib/%s/libhdf5_serial.so.103",
+    "usr/lib/%s/libhdf5_serial_hl.so.100",
+    "usr/lib/%s/libheif.so.1",
+    "usr/lib/%s/libhogweed.so.6",
+    "usr/lib/%s/libicudata.so.67",
+    "usr/lib/%s/libicui18n.so.67",
+    "usr/lib/%s/libicuuc.so.67",
+    "usr/lib/%s/libidn2.so.0",
+    "usr/lib/%s/libjbig.so.0",
+    "usr/lib/%s/libjpeg.so.62",
+    "usr/lib/%s/libjson-c.so.5",
+    "usr/lib/%s/libjson-glib-1.0.so.0",
+    "usr/lib/%s/libkmlbase.so.1",
+    "usr/lib/%s/libkmldom.so.1",
+    "usr/lib/%s/libkmlengine.so.1",
+    "usr/lib/%s/liblber-2.4.so.2",
+    "usr/lib/%s/liblcms2.so.2",
+    "usr/lib/%s/libldap_r-2.4.so.2",
+    "usr/lib/%s/libltdl.so.7",
+    "usr/lib/%s/liblz4.so.1",
+    "usr/lib/%s/libmariadb.so.3",
+    "usr/lib/%s/libmd.so.0",
+    "usr/lib/%s/libminizip.so.1",
+    "usr/lib/%s/libmount.so.1",
+    "usr/lib/%s/libnetcdf.so.18",
+    "usr/lib/%s/libnettle.so.8",
+    "usr/lib/%s/libnghttp2.so.14",
+    "usr/lib/%s/libnice.so.10",
+    "usr/lib/%s/libnspr4.so",
+    "usr/lib/%s/libnss3.so",
+    "usr/lib/%s/libnssutil3.so",
+    "usr/lib/%s/libodbc.so.2",
+    "usr/lib/%s/libodbcinst.so.2",
+    "usr/lib/%s/libopencv_core.so.4.5",
+    "usr/lib/%s/libopencv_highgui.so.4.5",
+    "usr/lib/%s/libopencv_imgcodecs.so.4.5",
+    "usr/lib/%s/libopencv_imgproc.so.4.5",
+    "usr/lib/%s/libopenjp2.so.7",
+    "usr/lib/%s/liborc-0.4.so.0",
+    "usr/lib/%s/libp11-kit.so.0",
+    "usr/lib/%s/libpango-1.0.so.0",
+    "usr/lib/%s/libpangocairo-1.0.so.0",
+    "usr/lib/%s/libpangoft2-1.0.so.0",
+    "usr/lib/%s/libpixman-1.so.0",
+    "usr/lib/%s/libplc4.so",
+    "usr/lib/%s/libplds4.so",
+    "usr/lib/%s/libpng16.so.16",
+    "usr/lib/%s/libpoppler.so.102",
+    "usr/lib/%s/libpq.so.5",
+    "usr/lib/%s/libproj.so.19",
+    "usr/lib/%s/libpsl.so.5",
+    "usr/lib/%s/libqhull.so.8.0",
+    "usr/lib/%s/librtmp.so.1",
+    "usr/lib/%s/librttopo.so.1",
+    "usr/lib/%s/libsasl2.so.2",
+    "usr/lib/%s/libsmime3.so",
+    "usr/lib/%s/libsoup-2.4.so.1",
+    "usr/lib/%s/libspatialite.so.7",
+    "usr/lib/%s/libsqlite3.so.0",
+    "usr/lib/%s/libsrtp2.so.1",
+    "usr/lib/%s/libssh2.so.1",
+    "usr/lib/%s/libsuperlu.so.5",
+    "usr/lib/%s/libsystemd.so.0",
+    "usr/lib/%s/libsz.so.2",
+    "usr/lib/%s/libtasn1.so.6",
+    "usr/lib/%s/libtbb.so.2",
+    "usr/lib/%s/libthai.so.0",
+    "usr/lib/%s/libtiff.so.5",
+    "usr/lib/%s/libudev.so.1",
+    "usr/lib/%s/libunistring.so.2",
+    "usr/lib/%s/liburiparser.so.1",
+    "usr/lib/%s/libuuid.so.1",
+    "usr/lib/%s/libv4l2.so.0",
+    "usr/lib/%s/libv4lconvert.so.0",
+    "usr/lib/%s/libvpx.so.6",
+    "usr/lib/%s/libwayland-client.so.0",
+    "usr/lib/%s/libwayland-cursor.so.0",
+    "usr/lib/%s/libwayland-egl.so.1",
+    "usr/lib/%s/libwayland-server.so.0",
+    "usr/lib/%s/libwebp.so.6",
+    "usr/lib/%s/libx264.so.160",
+    "usr/lib/%s/libx265.so.192",
+    "usr/lib/%s/libxcb-render.so.0",
+    "usr/lib/%s/libxcb-shm.so.0",
+    "usr/lib/%s/libxcb.so.1",
+    "usr/lib/%s/libxerces-c-3.2.so",
+    "usr/lib/%s/libxkbcommon.so.0",
+    "usr/lib/%s/libxml2.so.2",
+    "usr/lib/%s/libzstd.so.1",
+    "usr/lib/libarmadillo.so.10",
+    "usr/lib/libdfalt.so.0",
+    "usr/lib/libgdal.so.28",
+    "usr/lib/libmfhdfalt.so.0",
+    "usr/lib/libogdi.so.4.1",
+]
+
 cc_library(
     name = "gstreamer",
     srcs = cpu_select({
-        "amd64": [
-            "lib/x86_64-linux-gnu/libblkid.so.1",
-            "lib/x86_64-linux-gnu/libcom_err.so.2",
-            "lib/x86_64-linux-gnu/libexpat.so.1",
-            "lib/x86_64-linux-gnu/libkeyutils.so.1",
-            "lib/x86_64-linux-gnu/liblzma.so.5",
-            "lib/x86_64-linux-gnu/libmount.so.1",
-            "lib/x86_64-linux-gnu/libpcre.so.3",
-            "lib/x86_64-linux-gnu/libselinux.so.1",
-            "lib/x86_64-linux-gnu/libudev.so.1",
-            "lib/x86_64-linux-gnu/libuuid.so.1",
-            "lib/x86_64-linux-gnu/libz.so.1",
-            "usr/lib/x86_64-linux-gnu/libEGL.so.1",
-            "usr/lib/x86_64-linux-gnu/libGL.so.1",
-            "usr/lib/x86_64-linux-gnu/libGLX.so.0",
-            "usr/lib/x86_64-linux-gnu/libGLdispatch.so.0",
-            "usr/lib/x86_64-linux-gnu/libX11-xcb.so.1",
-            "usr/lib/x86_64-linux-gnu/libX11.so.6",
-            "usr/lib/x86_64-linux-gnu/libXau.so.6",
-            "usr/lib/x86_64-linux-gnu/libXdmcp.so.6",
-            "usr/lib/x86_64-linux-gnu/libatomic.so.1",
-            "usr/lib/x86_64-linux-gnu/libbsd.so.0",
-            "usr/lib/x86_64-linux-gnu/libdrm.so.2",
-            "usr/lib/x86_64-linux-gnu/libffi.so.6",
-            "usr/lib/x86_64-linux-gnu/libgbm.so.1",
-            "usr/lib/x86_64-linux-gnu/libgio-2.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libglib-2.0.so",
-            "usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgmp.so.10",
-            "usr/lib/x86_64-linux-gnu/libgnutls.so.30",
-            "usr/lib/x86_64-linux-gnu/libgobject-2.0.so",
-            "usr/lib/x86_64-linux-gnu/libgssapi_krb5.so.2",
-            "usr/lib/x86_64-linux-gnu/libgssdp-1.0.so.3",
-            "usr/lib/x86_64-linux-gnu/libgstallocators-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstapp-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstaudio-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstbadvideo-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstbase-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstgl-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstreamer-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstrtp-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstsdp-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgsttag-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstvideo-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgstwebrtc-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgudev-1.0.so.0",
-            "usr/lib/x86_64-linux-gnu/libgupnp-1.0.so.4",
-            "usr/lib/x86_64-linux-gnu/libgupnp-igd-1.0.so.4",
-            "usr/lib/x86_64-linux-gnu/libhogweed.so.4",
-            "usr/lib/x86_64-linux-gnu/libicudata.so.63",
-            "usr/lib/x86_64-linux-gnu/libicui18n.so.63",
-            "usr/lib/x86_64-linux-gnu/libicuuc.so.63",
-            "usr/lib/x86_64-linux-gnu/libidn2.so.0",
-            "usr/lib/x86_64-linux-gnu/libjpeg.so.62",
-            "usr/lib/x86_64-linux-gnu/libk5crypto.so.3",
-            "usr/lib/x86_64-linux-gnu/libkrb5.so.3",
-            "usr/lib/x86_64-linux-gnu/libkrb5support.so.0",
-            "usr/lib/x86_64-linux-gnu/libnettle.so.6",
-            "usr/lib/x86_64-linux-gnu/libnice.so.10",
-            "usr/lib/x86_64-linux-gnu/libopencv_core.so.3.2",
-            "usr/lib/x86_64-linux-gnu/liborc-0.4.so.0",
-            "usr/lib/x86_64-linux-gnu/libp11-kit.so.0",
-            "usr/lib/x86_64-linux-gnu/libpsl.so.5",
-            "usr/lib/x86_64-linux-gnu/libsoup-2.4.so.1",
-            "usr/lib/x86_64-linux-gnu/libsqlite3.so.0",
-            "usr/lib/x86_64-linux-gnu/libtasn1.so.6",
-            "usr/lib/x86_64-linux-gnu/libtbb.so.2",
-            "usr/lib/x86_64-linux-gnu/libunistring.so.2",
-            "usr/lib/x86_64-linux-gnu/libvpx.so.5",
-            "usr/lib/x86_64-linux-gnu/libwayland-client.so.0",
-            "usr/lib/x86_64-linux-gnu/libwayland-egl.so.1",
-            "usr/lib/x86_64-linux-gnu/libwayland-server.so.0",
-            "usr/lib/x86_64-linux-gnu/libx265.so.165",
-            "usr/lib/x86_64-linux-gnu/libxcb.so.1",
-            "usr/lib/x86_64-linux-gnu/libxml2.so.2",
-        ],
+        "amd64": [s % "x86_64-linux-gnu" if "%" in s else s for s in _common_srcs_list],
         "roborio": [
         ],
         "armhf": [
@@ -159,34 +307,42 @@
             "usr/lib/arm-linux-gnueabihf/libxcb.so.1",
             "usr/lib/arm-linux-gnueabihf/libxml2.so.2",
         ],
-        "arm64": [],
+        "arm64": [s % "aarch64-linux-gnu" if "%" in s else s for s in _common_srcs_list],
         "cortex-m": [],
         "cortex-m0plus": [],
     }),
     hdrs = glob([
+        "usr/lib/aarch64-linux-gnu/glib-2.0/include/**/*.h",
+        "usr/lib/arm-linux-gnueabihf/glib-2.0/include/**/*.h",
         "usr/lib/x86_64-linux-gnu/glib-2.0/include/**/*.h",
         "usr/include/gstreamer-1.0/**/*.h",
         "usr/include/glib-2.0/**/*.h",
-        "usr/lib/arm-linux-gnueabihf/glib-2.0/include/**/*.h",
+        "usr/include/libsoup-2.4/**/*.h",
+        "usr/include/json-glib-1.0/**/*.h",
+        "usr/include/opencv4/**",
+        "usr/include/X11/**",
     ]),
     includes = cpu_select({
         "amd64": [
             "usr/lib/x86_64-linux-gnu/glib-2.0/include",
-            "usr/include",
-            "usr/include/glib-2.0",
-            "usr/include/gstreamer-1.0",
         ],
         "armhf": [
             "usr/lib/arm-linux-gnueabihf/glib-2.0/include",
-            "usr/include",
-            "usr/include/glib-2.0",
-            "usr/include/gstreamer-1.0",
         ],
-        "arm64": [],
+        "arm64": [
+            "usr/lib/aarch64-linux-gnu/glib-2.0/include",
+        ],
         "roborio": [],
         "cortex-m": [],
         "cortex-m0plus": [],
-    }),
+    }) + [
+        "usr/include",
+        "usr/include/glib-2.0",
+        "usr/include/gstreamer-1.0",
+        "usr/include/libsoup-2.4",
+        "usr/include/json-glib-1.0",
+        "usr/include/opencv4",
+    ],
     linkopts = [
         "-ldl",
         "-lresolv",
diff --git a/debian/gstreamer_amd64.bzl b/debian/gstreamer_amd64.bzl
index 2d1558b..59f3d59 100644
--- a/debian/gstreamer_amd64.bzl
+++ b/debian/gstreamer_amd64.bzl
@@ -1,511 +1,524 @@
 files = {
-    "adduser_3.118_all.deb": "bd71dd1ab8dcd6005390708f23741d07f1913877affb7604dfd55f85d009aa2b",
-    "adwaita-icon-theme_3.30.1-1_all.deb": "698b3f0fa337bb36ea4fe072a37a32a1c81875db13042368677490bb087ccb93",
-    "coreutils_8.30-3_amd64.deb": "ae6e5cd6e9aaf74d66edded3931a7a6c916625b8b890379189c75574f6856bf4",
-    "dconf-gsettings-backend_0.30.1-2_amd64.deb": "8dd9f676ed51db557cfdbb107542bf5406627dc1c83ded565149f02abb60e268",
-    "dconf-service_0.30.1-2_amd64.deb": "1adc68353e17f12ceb3f2e01bb0cb4e5d11b547b9436a89fa0209c46cf028c51",
-    "fontconfig-config_2.13.1-2_all.deb": "9f5d34ba20eb156ef62d8126866a376be985c6a83fdcfb33f12cd83acac480c2",
-    "fontconfig_2.13.1-2_amd64.deb": "efbc7d9a8cf245e31429d3bda3e560df275f6b7302367aabe83503ca734ac0fd",
-    "fonts-dejavu-core_2.37-1_all.deb": "58d21a255606191e6512cca51f32c4480e7a798945cc980623377696acfa3cfc",
-    "fonts-freefont-ttf_20120503-9_all.deb": "13489f628898f01ad4ab12807309d814cf6df678a2ae9c1e49a426d1c916a1c5",
-    "fonts-liberation_1.07.4-9_all.deb": "c936aebbfd0af7851399ae5ab08bb01744f5e3381f7678fb87cc77114f95ef53",
-    "gdal-data_2.4.0+dfsg-1_all.deb": "6e0fce32cf2e85ad2539482087d712bf2258d05e1838f3586a17ad2dc6bb7410",
-    "gir1.2-glib-2.0_1.58.3-2_amd64.deb": "21843844415a72bda1f3f524dfcff94550128b082f31b850f5149552ae171264",
-    "gir1.2-gst-plugins-bad-1.0_1.14.4-1+b1_amd64.deb": "a3d18fa2e46485f192acc72d3f5e8062c541a4f68864e3f27ea4d6f599c67b2c",
-    "gir1.2-gst-plugins-base-1.0_1.14.4-2_amd64.deb": "9ace033e35ee9a6b6a42ab3bd28c26c32afc98401e933599fd4a25a009e27f29",
-    "gir1.2-gstreamer-1.0_1.14.4-1_amd64.deb": "b66c3872d9cb4e3c61c9863741ca9c551edbd9ba88347b3bd3f74d116e9d9072",
-    "glib-networking-common_2.58.0-2_all.deb": "79831fd09fc96dc5729e8ed360563b05100d6bff70b03f3badf4e0f4759bb7ec",
-    "glib-networking-services_2.58.0-2_amd64.deb": "fc3bbb1b8f14c7aaa2f873cc006c0d2f8c3a4c712bc067d749adafa82635e094",
-    "glib-networking_2.58.0-2_amd64.deb": "21854f3921469776a598369a5b5b5264112bf49de1559c219fbe36cbd702628f",
-    "gsettings-desktop-schemas_3.28.1-1_all.deb": "a75aed8781a781c4b819b2d1e952791b123580b1a02a4bb35fdbbba2e3ab8310",
-    "gstreamer1.0-plugins-bad_1.14.4-1+b1_amd64.deb": "8ec300a7c1485ef8128b75d4015eef29e8e56eb8a8005d9bfba78a33bd19afa8",
-    "gstreamer1.0-plugins-base_1.14.4-2_amd64.deb": "c62e46eae5b671176285e50268f342432b73293e7ebf149f036357e577f3f4fc",
-    "gstreamer1.0-plugins-good_1.14.4-1_amd64.deb": "5788cd63e8479309e75a395e951067088df9a934aba6d992261e819f4cd2decb",
-    "gstreamer1.0-plugins-ugly_1.14.4-1_amd64.deb": "94af175fc2f304771a962b89c5fe4d05e098eae48a145e36953f204893f003cd",
-    "gtk-update-icon-cache_3.24.5-1_amd64.deb": "ca87a8eaa7a662049e2a95f3405d8affb7715a9dbdcba6fa186ae0bcc8981847",
+    "adwaita-icon-theme_3.38.0-1_all.deb": "2046876c82fc1c342b38ace9aa0661bcb3e167837c984b4bdc89702bc78df5ac",
+    "coreutils_8.32-4+b1_amd64.deb": "3558a412ab51eee4b60641327cb145bb91415f127769823b68f9335585b308d4",
+    "dconf-gsettings-backend_0.38.0-2_amd64.deb": "194991ed5f4ab1ca25413858cb99c910391cfd6d3b1b6a3d3e56a4b3a706a37d",
+    "dconf-service_0.38.0-2_amd64.deb": "639125f7a44d11f96661c61a07abbb58da0e5636ed406ac186adcef8651775c2",
+    "fluidr3mono-gm-soundfont_2.315-7_all.deb": "4098301bf29f4253c2f5799a844f42dd4aa733d91a210071ad16d7757dea51d6",
+    "fontconfig-config_2.13.1-4.2_all.deb": "48afb6ad7d15e6104a343b789f73697301ad8bff77b69927bc998f5a409d8e90",
+    "fontconfig_2.13.1-4.2_amd64.deb": "c594a100759ef7c94149359cf4d2da5fb59ef30474c7a2dde1e049d32b9c478a",
+    "fonts-croscore_20201225-1_all.deb": "64904820b729ff40038f85683004e3b94b328d969bc0fbba263c58d635452923",
+    "fonts-dejavu-core_2.37-2_all.deb": "1f67421437b6eb18669d2868e3e02cb88668683d635198142f48aacc5b397118",
+    "fonts-freefont-otf_20120503-10_all.deb": "0b63996c80c6c660424af6d3832818e647960d6f65a51de010bb57dd0762faa7",
+    "fonts-freefont-ttf_20120503-10_all.deb": "4ca1c21ebc479198a3a5879d236c8317d6f7b2f1c403f7890e24c02eead05615",
+    "fonts-liberation2_2.1.3-1_all.deb": "e0805f0085132f5e6dd30f88c0d7260caf1e5450832fe2e3988a20fa9fa2150e",
+    "fonts-liberation_1.07.4-11_all.deb": "efd381517f958b01969343634ffcbdd60056be7779af84c6f53a005090430204",
+    "fonts-texgyre_20180621-3.1_all.deb": "cb7e9a4b2471cfdd57194c16364f9102f0639816a2662fed4b30d2a158747076",
+    "fonts-urw-base35_20200910-1_all.deb": "f95a139adb7f1b60626e76d4d45d1b35aad1bc2c2597394c291ef5f84b5dcb43",
+    "gdal-data_3.2.2+dfsg-2+deb11u1_all.deb": "3ae44cc2f51dccc023f9c3cfbea3411508e24f1335651fa0e6cba74b7b9b87aa",
+    "gir1.2-glib-2.0_1.66.1-1+b1_amd64.deb": "1163a4e7eb095e37752739c0065bad50fa2177c13a87e7c1b0d44ed517fe8c91",
+    "gir1.2-gst-plugins-bad-1.0_1.20.1-1~bpo11+1_amd64.deb": "83575d0b8a14c535f8193e8c37885d6523434a8408c128821f9f7cb95962cc57",
+    "gir1.2-gst-plugins-base-1.0_1.20.1-1~bpo11+1_amd64.deb": "79fdb139b1d6a2ae6ce899d776bbb11b0f693018b6eec562dfe973ec7df6e306",
+    "gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_amd64.deb": "312820f8d42f1a052de1db82483e1cfed0fd36b229f9dfd9397537a7ee808798",
+    "gir1.2-gudev-1.0_234-1_amd64.deb": "c9560915329dafdfb32998eb3e90cbb0f37f53134c69c1d5acef070754e36e01",
+    "gir1.2-json-1.0_1.6.2-1_amd64.deb": "c44783e0b94d6a6792ffd837d1e97ebb8ca6ccb8beaf7abe295e367cd92a1b7d",
+    "gir1.2-soup-2.4_2.72.0-2_amd64.deb": "064523a0f3121f9014f9dabd3add9e8441f5e24ac181345a5673b4e0105a4286",
+    "glib-networking-common_2.66.0-2_all.deb": "a07370151ce5169e48ee7799b9bd9a7a035467a21f5cf3373b2aff090968609c",
+    "glib-networking-services_2.66.0-2_amd64.deb": "19131c7c31bc3fae604df30d2f73c3e8338ffeb2988fe167bb8b2b1c8913c9ab",
+    "glib-networking_2.66.0-2_amd64.deb": "b2cd50a8c3b30c16fd1a19c5244f681c6c0d1f426c385d44900477b052f70024",
+    "gsettings-desktop-schemas_3.38.0-2_all.deb": "3758968491a770e50cd85122c00d141944ffb43cb7a5c886a37290fef848cee3",
+    "gstreamer1.0-nice_0.1.18-2~bpo11+1_amd64.deb": "6f8d8bd4119359c73f0978db064b1ffd3f9cfc3f3f9e3f198f04457655808259",
+    "gstreamer1.0-plugins-bad_1.20.1-1~bpo11+1_amd64.deb": "6e948e0c065e5a1662d1a307e29c9afaaa91a1e0d1cbb2caddeff581efe8a5c1",
+    "gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_amd64.deb": "c7910b0b45f844b72852f861bf9470a002b138c926accf3adc6cb86484dd981d",
+    "gstreamer1.0-plugins-good_1.20.1-1~bpo11+1_amd64.deb": "cc40a58c68afce8fe7ffde9f1a5d5be50cbb33e1dde435eab5d03c6e032cb695",
+    "gstreamer1.0-plugins-ugly_1.20.1-1~bpo11+1_amd64.deb": "04605a67ca9fccbea5d5c312f66fb6606200f222573a03ee39709786e02f2fc5",
+    "gtk-update-icon-cache_3.24.24-4+deb11u2_amd64.deb": "b877617f382240663be1010510511a5f9fe10853a3f97088cc01be277ff184d6",
     "hicolor-icon-theme_0.17-2_all.deb": "20304d34b85a734ec1e4830badf3a3a70a5dc5f9c1afc0b2230ecd760c81b5e0",
-    "iso-codes_4.2-1_all.deb": "72d0589fc065005574232bf103c7d34acf5e4c805f2b0d19e6aeb639438ff253",
-    "liba52-0.7.4_0.7.4-19_amd64.deb": "e9e40412ef190d42a7f42c1ebbf6198b3cc46a19a9b42d24fd6c49c9a1970192",
-    "libaa1_1.4p5-46_amd64.deb": "2311c88fcd1662319576f4b265c665c08cdf061cff7e4557885f32f6678eeed8",
-    "libaec0_1.0.2-1_amd64.deb": "18193039d49a7944623f7a175af6d3d0c01ff39f724ee42041c2f6511acfcc9a",
-    "libaom0_1.0.0-3_amd64.deb": "22f071d9b5fbc62bdb01aa49fa6a423948ffdafec40eda52b9f0de0d332278f1",
-    "libarmadillo9_9.200.7+dfsg-1_amd64.deb": "1f5ba72600963a7a4cd6f2035f032ef59a8c3169e85e1f3e7f12271a2d1ebd62",
-    "libarpack2_3.7.0-2_amd64.deb": "08b83c081ba569bd61ee67ff39da490690389eb15c52d0a3f8d12a51f9debc90",
-    "libatk-bridge2.0-0_2.30.0-5_amd64.deb": "52ed3333fd0e1430b573343fc65d594a075ee5f493b8cbff0f64d5f41f6f3f8f",
-    "libatk1.0-0_2.30.0-2_amd64.deb": "51603cc054baa82cee4cd50ac41578266e1321ef1c74bccbb78a3dcf1729d168",
-    "libatk1.0-data_2.30.0-2_all.deb": "cf0c94611ff2245ae31d12a5a43971eb4ca628f42e93b0e003fd2c4c0de5e533",
-    "libatomic1_8.3.0-6_amd64.deb": "f3aed76145c49f0b6be3eb6840abc4245eebf24448b55c8ed0736fc1d45e5f8a",
-    "libatspi2.0-0_2.30.0-7_amd64.deb": "8ff1ab1508799679e3209188c5f4765c3da16a7876e220c49d805ef03cced397",
-    "libaudit-common_2.8.4-3_all.deb": "4e51dc247cde083528d410f525c6157b08be8b69511891cf972bc87025311371",
-    "libaudit1_2.8.4-3_amd64.deb": "21f2b3dfbe7db9e15ff9c01e1ad8db35a0adf41b70a3aa71e809f7631fc2253d",
-    "libavahi-client3_0.7-4+b1_amd64.deb": "ab80126c56e9aa8fd3b2ef5991b547bd15eb41cd78919fa55c55d221a9d349e9",
-    "libavahi-common-data_0.7-4+b1_amd64.deb": "388bc38faf2ad715b9c383daa7c358c656c05de33886c2da7e3641db6bdf5512",
-    "libavahi-common3_0.7-4+b1_amd64.deb": "82ee379d69de764c2fc1663535e43fabad7e31247a6fae7d492b5a0446a730c3",
+    "icu-devtools_67.1-7_amd64.deb": "0a89d6f360d9c686c08d0156a0c8244715c9aaeffca079cf1716f12cffece82e",
+    "iso-codes_4.6.0-1_all.deb": "4e044d72a9f810aabf2c8addf126327fa845eaf8e983b51eb6356b9ed5108348",
+    "liba52-0.7.4_0.7.4-20_amd64.deb": "da214eaeeeca241ae0bf22e7ad180d8e47603c227583a3e136471df40218bff3",
+    "libaa1_1.4p5-48_amd64.deb": "5fb458e3354308f88161e9bb22c114001a1cc241ebe4915fe6cc11b4ffe533ac",
+    "libaec0_1.0.4-1_amd64.deb": "2d784ab4a922112cc1c3aab0164486e7829fc705913c9ba8bc62a0642d18b8bd",
+    "libaom0_1.0.0.errata1-3_amd64.deb": "900f94cd878e6ba2acf87a2a324838736d5085b436f9bf615b2a3ed0345f8a0d",
+    "libarchive13_3.4.3-2+deb11u1_amd64.deb": "42530f8ae7e5787bd6d269cda49b651c6920db0b18844d71fc960b12cc271259",
+    "libarmadillo10_10.1.2+dfsg-6+b1_amd64.deb": "54daff607308fadf5662836e422442bef3e4435ad56ca669f3d3de4ff41ba2ab",
+    "libarpack2_3.8.0-1_amd64.deb": "c51364e5681e1268f201a57969a4a029d71d3239be993934fad59428b96f588e",
+    "libasound2-data_1.2.4-1.1_all.deb": "76211f5f201ad1069b95d047863e0c1b51d8400c874b59e00f24f31f972b4036",
+    "libasound2_1.2.4-1.1_amd64.deb": "d8c9b5182768db2a7c5c73f1eed0b1be1431ae4f41084d502b325d06d5b0f648",
+    "libass9_0.15.0-2_amd64.deb": "96d52690cfb7c6ff20bea4dc5b931c2da432fc264a9e87388ce3ce2f83f2fca8",
+    "libasyncns0_0.8-6+b2_amd64.deb": "bef9c0ef5c8eeded91a1545b5c66c16aa60775b975bc9747d4b0dccf597d2a4d",
+    "libatk-bridge2.0-0_2.38.0-1_amd64.deb": "65b063b4b45c5fd60d91e374d01bb73eacdb30c545a6ef0873d07d6da97765d1",
+    "libatk1.0-0_2.36.0-2_amd64.deb": "572cd62f92ec25c75b98617321373d46a6717cbcc93d2025ebd6d550f1abf901",
+    "libatk1.0-data_2.36.0-2_all.deb": "86c1acae473977f8a78b905090847df654306996324493f9a39d9f27807778b2",
+    "libatspi2.0-0_2.38.0-4_amd64.deb": "53435278eb8815aafbb41db29a691a43a9de16fa58d9bc7908a1f6f2a07f0b67",
+    "libattr1_2.4.48-6_amd64.deb": "af3c3562eb2802481a2b9558df1b389f3c6d9b1bf3b4219e000e05131372ebaf",
+    "libavahi-client3_0.8-5_amd64.deb": "697dff4185adc2912ee2b27c91bfb4fece4376dde2158dc7249a69498e4c0db0",
+    "libavahi-common-data_0.8-5_amd64.deb": "37595c0c6876ac914f66b081063a8522fb255afadb76e5613343a1d653beca0d",
+    "libavahi-common3_0.8-5_amd64.deb": "1300d89d5fb920753aee4c2b47b1ab1ef60533abe9875ba203096738f4cfb692",
     "libavc1394-0_0.5.4-5_amd64.deb": "f96e824b1a7e8d9ae1254c51dfaea40cdde45072be68e2025eb109faba10f3dc",
-    "libavcodec-dev_4.1.4-1~deb10u1_amd64.deb": "e7704b27d393f99c4d31b2dbdd45de7aebadefdcc0760d5c496931f815b3e373",
-    "libavcodec58_4.1.4-1~deb10u1_amd64.deb": "06a7c8232bb6ae761713bb409a7007691f68c8fa1a06d7e172cc1af2a0b248d5",
-    "libavformat-dev_4.1.4-1~deb10u1_amd64.deb": "74f8f220f91b09514aee4082c6517d82e2903ae3a93c5182a9d5172071b4bce3",
-    "libavformat58_4.1.4-1~deb10u1_amd64.deb": "4898fe7f8bf5d759ced3c30045e12784295ec3dbda430cdd05c5733e80448009",
-    "libavresample-dev_4.1.4-1~deb10u1_amd64.deb": "d33a192f435f1ca2a2e8d1c76f3a745423666c5e57c4041249743adc6917dcc1",
-    "libavresample4_4.1.4-1~deb10u1_amd64.deb": "22c4dbc129e1f67e8c9b0a50c05aafe4ed21eed1b825a39f356e3d2b2a4cbcd4",
-    "libavutil-dev_4.1.4-1~deb10u1_amd64.deb": "c835b7e0ab29b0b22611b0e373e8a4a4be653a547c50ff27a5aedd5755900aff",
-    "libavutil56_4.1.4-1~deb10u1_amd64.deb": "cec6a4827449633d9ce36a1f97e109ae38792fea5b39381da8c38431a3796863",
-    "libblas3_3.8.0-2_amd64.deb": "7161d85be1e755bb605b2a3f65d7c556c5851ed0379b723b3f9d54a5eada5fd5",
-    "libblkid-dev_2.33.1-0.1_amd64.deb": "996914d6cec1bac151c766d5b65197888b464c3505f63f7abbc129d74e5f28ac",
-    "libblkid1_2.33.1-0.1_amd64.deb": "0b15f3eb3cf2fbe540f99ae1c9fd5ec1730f2245b99e31c91755de71b967343a",
-    "libbluray2_1.1.0-1_amd64.deb": "df82a7141cd2f3c212ad805e83be01b04e90cf095638bf11fbf7c790d4027452",
-    "libbsd0_0.9.1-2_amd64.deb": "0827321e85d36200759e3ec621fc05154c752534c330ffc5472ad75bbb8eb913",
-    "libcaca0_0.99.beta19-2.1_amd64.deb": "2f21fa1c7691803c0250930140d07f1c4671574063bcc977e97b92a26a465c47",
-    "libcairo-gobject2_1.16.0-4_amd64.deb": "5579ae5d311dbd71556dc36edf2bb39ba73f5aa65a8a5367bd93e96a4c98f69e",
-    "libcairo2_1.16.0-4_amd64.deb": "32fcf6fb0cffe41263927f692a88911796c9006402b6cc2137ca78db3c96068e",
-    "libcap-ng0_0.7.9-2_amd64.deb": "4f9caf61638db6dcf79529ef756a2d36c7aae6604d486a5055bb3212d823b691",
-    "libcap2-bin_2.25-2_amd64.deb": "3c8c5b1410447356125fd8f5af36d0c28853b97c072037af4a1250421008b781",
-    "libcap2_2.25-2_amd64.deb": "8f93459c99e9143dfb458353336c5171276860896fd3e10060a515cd3ea3987b",
-    "libcdio18_2.0.0-2_amd64.deb": "caafbabaffef90d57250196e26357070fcc739387f41f5d9b8d7340696438157",
-    "libcdparanoia0_3.10.2+debian-13_amd64.deb": "df50318f333569808c1bad8448212113be8f3dba62d508f2211672dd88fc3d6b",
-    "libcharls2_2.0.0+dfsg-1_amd64.deb": "04489cf5717651fb958c923950b185616d468c615fc1fcdd138ba1abd549c9b4",
-    "libchromaprint1_1.4.3-3_amd64.deb": "22eab07031e801fa1d450247451cac9023494221583760b31faa9e67aa051d32",
-    "libcodec2-0.8.1_0.8.1-2_amd64.deb": "49603d461161ed9e77d848f3f203b5ad49ab7b6498202492ceb03c948a4481b3",
-    "libcolord2_1.4.3-4_amd64.deb": "2fd78fc761cc8465702ce4ec03bc6922b172e47f524c7c64312dcf2ad0db1489",
-    "libcom-err2_1.44.5-1+deb10u3_amd64.deb": "e5ea8e6db9453ed13199f4cbfe8e29d76c579eb6f678ab9bb4bebd7d12c1936e",
-    "libcroco3_0.6.12-3_amd64.deb": "1acb00996b7477687e4f3f12de7fbf4b635866a6167671f2201ea3e67af05336",
-    "libcrystalhd3_0.0~git20110715.fdd2f19-13_amd64.deb": "e2dab38126a0b92abdc149397307f9af3f04f5aa26ae08a1ed461a0178f4b1fe",
-    "libcups2_2.2.10-6+deb10u2_amd64.deb": "d5dea9519516290f4f424099add8b6bb77d77c188ccca23073d855517c13b79c",
-    "libcurl3-gnutls_7.64.0-4_amd64.deb": "da6d0e4c58d09d767e10c5d7653504c778fe8a6dcd1accf0fa713102d17338a9",
-    "libdap25_3.20.3-1_amd64.deb": "f897c1f533b513da49fee93d9c912b791b809833fe8ad7dbf6505f62e8f2d47e",
-    "libdapclient6v5_3.20.3-1_amd64.deb": "80cabdf76dead855c54e583848b366994590ebf321fc21c133ec46beabdc67a7",
-    "libdapserver7v5_3.20.3-1_amd64.deb": "49c7c5f18b78bbcf73c298469ea8fbc12f5c154b3d1b926584df1b087d6d1659",
-    "libdatrie1_0.2.12-2_amd64.deb": "7159a08f4a40f74e4582ebd62db0fb48b3ba8e592655ac2ab44f7bfacbca12f3",
-    "libdb5.3_5.3.28+dfsg1-0.5_amd64.deb": "c7f0e9a423840731362ee52d4344c0bcf84318fbc06dad4fefe0e61d9e7062bc",
-    "libdbus-1-3_1.12.16-1_amd64.deb": "b6667d3d29f2a4b5efb3f7368eb750582341ab0554213246d2d6713af09e552f",
-    "libdc1394-22-dev_2.2.5-1_amd64.deb": "2ed94c28030329432642aff77553f843c264ed391becc6d72ab2da52088ddac1",
-    "libdc1394-22_2.2.5-1_amd64.deb": "ba076aaa8e60f2203fbd1734c822558c5875eab35c8731fb6e42a2244390ffa2",
-    "libdconf1_0.30.1-2_amd64.deb": "22775563fd803db3dafe4fcc93950f72acf04e3d87b51b3dd5c107b21105a5ff",
-    "libdpkg-perl_1.19.7_all.deb": "1cb272a8168138e9b8334e87cc26388259f232b74667b3a7f3856f227adcc4ba",
-    "libdrm-amdgpu1_2.4.97-1_amd64.deb": "283bff4909f50da051f057cf6b8e84c590675ede91e57ce7414d2f1d4097b691",
-    "libdrm-common_2.4.97-1_all.deb": "eea378d3dab56923e06871331838aecc38a35aad997da7fc96a5e8c4e36081a2",
-    "libdrm-dev_2.4.97-1_amd64.deb": "8b5197c40c5feb0a096befae273880ff904d44cd4853c136c8a5ff9ea7d24558",
-    "libdrm-intel1_2.4.97-1_amd64.deb": "d5cb66f82681192ae14157370c98fc12bac0331283a8afd6b2c9c1a70c910a57",
-    "libdrm-nouveau2_2.4.97-1_amd64.deb": "875b604283ad5b56fb0ae0ec28b4e52ba3055ce9116e71d4bcec7854b67ba7b6",
-    "libdrm-radeon1_2.4.97-1_amd64.deb": "e7e98f7beedfb326a3dc4d2cef3eff144c7cfe22bef99c2004708c1aa5cceb8c",
-    "libdrm2_2.4.97-1_amd64.deb": "759caef1fbf885c515ae7273cdf969d185cf7276b432a813c46651e468c57489",
-    "libdv4_1.0.0-12_amd64.deb": "cbff9d3d56bcc5f30227ce893b5250fd0008092b30c7c004f1abe98229dd88d5",
-    "libdvdread4_6.0.1-1_amd64.deb": "68621b27c8d2334c225a9d2de48acca21e51f0a7517674ba1a699e9d81a168f3",
-    "libedit2_3.1-20181209-1_amd64.deb": "ccd6cdf5ec28a92744a79f3f210f071679d12deb36917d4e8d17ae7587f218cc",
-    "libegl-mesa0_18.3.6-2+deb10u1_amd64.deb": "cdfd118d0dcb5fcc0eeb3a57c7c630acc51644328a67c0fe06baaf87f701527b",
-    "libegl1-mesa-dev_18.3.6-2+deb10u1_amd64.deb": "626a86cda8833cf45ac20299237ca8e7d831e04acb3716b846581ed567b367f6",
-    "libegl1_1.1.0-1_amd64.deb": "a5d56bc4fc21a87f95b45ca9665abae5390809bc8d2d8fd3a3c3fc15eeeb1918",
-    "libelf1_0.176-1.1_amd64.deb": "cc7496ca986aa77d01e136b8ded5a3e371ec8f248b331b4124d1fd2cbeaec3ef",
-    "libepoxy0_1.5.3-0.1_amd64.deb": "968295ae7382be0fc06e535f2a1408f54b0b29096e0142618d185da1c7a42ed0",
-    "libepsilon1_0.9.2+dfsg-4_amd64.deb": "f8908300afd1436d471f0b14da2078f7ceeb5171748ab24b32b77b7c83039295",
-    "libevent-2.1-6_2.1.8-stable-4_amd64.deb": "ffebc078745662d2308c0026cc50e37cb54344bde61b1f92b979a2a4e8138efe",
-    "libevent-core-2.1-6_2.1.8-stable-4_amd64.deb": "a96168d513725033c6558c49b191ae192a0eb3b92dd574f540b163ce19549323",
-    "libevent-pthreads-2.1-6_2.1.8-stable-4_amd64.deb": "d2012b6f09029fd2c9a8d7a423fc7afb2fcc86c1b4b1dd46659b7e08f20e5a68",
-    "libexif-dev_0.6.21-5.1_amd64.deb": "0da4fda369950ab0e8cd6d743e294ef42cd75b5a7e4c7cec0559bf44e50d39ba",
-    "libexif12_0.6.21-5.1_amd64.deb": "75052c4cd070441379acfe1332bed3200ed55f92852c71b8253608766347af86",
-    "libexpat1_2.2.6-2+deb10u1_amd64.deb": "d60dee1f402ee0fba6d44df584512ae9ede73e866048e8476de55d9b78fa2da1",
-    "libfabric1_1.6.2-3_amd64.deb": "71358ea6a57ec41309f23826cfff4e83aabe569cec50e6ce635740c63e2b8654",
-    "libffi-dev_3.2.1-9_amd64.deb": "643bf19e859c9bf8f61033e48d7ba73c114039efbe851f407356edab396af317",
-    "libffi6_3.2.1-9_amd64.deb": "d4d748d897e8e53aa239ead23a18724a1a30085cc6ca41a8c31b3b1e1b3452f4",
-    "libflac8_1.3.2-3_amd64.deb": "e736a3b67bd9e5a627dbfe44c08c84d59c650e8ec3b6b7f24839ff740944d7d0",
-    "libfontconfig1_2.13.1-2_amd64.deb": "6766d0bcfc615fb15542efb5235d38237ccaec4c219beb84dbd22d1662ccea8f",
-    "libfreetype6_2.9.1-3+deb10u1_amd64.deb": "9ebd43849f483b79f6f1e0d9ba398faafb23f55a33ea916821b13991ba821a2a",
-    "libfreexl1_1.0.5-3_amd64.deb": "5e41fb4438c7c655894b111eced2b9697fb5f5bab6ddf12d7cb7fb680725c17e",
-    "libfribidi0_1.0.5-3.1+deb10u1_amd64.deb": "9844b02a3bfa8c9f89a077cc5208122f9245a6a6301cbf5fdc66b1a76f163c08",
-    "libfyba0_4.1.1-6_amd64.deb": "70da7c23ef1b12f01d0e5a5062c9ee0bbeec2b87d6c517db9bfa34def51601bf",
-    "libgbm1_18.3.6-2+deb10u1_amd64.deb": "74c468c77990d871243ae31c108b7b770f5a0ff02fd36316f70affe52bce1999",
-    "libgcrypt20_1.8.4-5_amd64.deb": "1b826517b328e29a441cc89e5c427896182ffc946713329f50accc8417856136",
-    "libgd3_2.2.5-5.2_amd64.deb": "ee49ded27e44a8fd04710458413c0203704a2fd4e30497d5eb64f46695816633",
-    "libgdal20_2.4.0+dfsg-1+b1_amd64.deb": "4fb22452c0ee831156373d77d8950f578d24a08f3b009ed416df148ef0e5b0b4",
-    "libgdcm2-dev_2.8.8-9_amd64.deb": "0461bf270ea31e4c1c8d0366cbcd01948b2f0bf9dbcafe400dbe6c82df0703ff",
-    "libgdcm2.8_2.8.8-9_amd64.deb": "002349ae3eb032c6594d1269e66048b6f430989049213c83a206695b74d22e95",
-    "libgdk-pixbuf2.0-0_2.38.1+dfsg-1_amd64.deb": "90e1842771968ffae4b4c28f1ad6a8bf77ff3a57616b799abed93354b860edc8",
-    "libgdk-pixbuf2.0-common_2.38.1+dfsg-1_all.deb": "1310e3f0258866eb4d0e95f140d5d9025cf6be1e3e2c375f4a426ccc2e78cf68",
-    "libgeos-3.7.1_3.7.1-1_amd64.deb": "5db308a68fa4d3f92f718cdfa3bccdab0bc81e955eb68b739f93395fcd551f5f",
-    "libgeos-c1v5_3.7.1-1_amd64.deb": "f9e0dd7cdcbf071840f2f95e5c913dfc3256111f4ba0faa772a4f60a80176fa2",
-    "libgeotiff2_1.4.3-1_amd64.deb": "9d1a005e1268e71fe64a0087f66750ec661967107307da6738647ac31ff845a6",
-    "libgfortran5_8.3.0-6_amd64.deb": "c76cb39bb3da74c5315e0d9577adc45bd39bf2d21fb7885e724429e5b4ed0ffe",
-    "libgif7_5.1.4-3_amd64.deb": "a7d7610a798cf3d72bf5ef9f6e44c4b0669f5df3e4a0014e83f9d788ce47f9a9",
-    "libgirepository-1.0-1_1.58.3-2_amd64.deb": "6db170195856b430d580e6ecf528b2efaf66233a98884368658fbef5abe4eaa5",
-    "libgl1-mesa-dev_18.3.6-2+deb10u1_amd64.deb": "fd7b17e82f1ccf95d5a2da726a3e183a5f01f7c3b0aac36c70b2ebc5d1903fcd",
-    "libgl1-mesa-dri_18.3.6-2+deb10u1_amd64.deb": "964968e2914e86eca243c9a316529a4d2f8b6e000f981e9a0891ac3c3550be32",
-    "libgl1_1.1.0-1_amd64.deb": "79420dd0cdb5b9dab9d3266c8c052036c93e363708e27738871692e0e163e5a2",
-    "libgl2ps1.4_1.4.0+dfsg1-2_amd64.deb": "b24681fc4d4594d5ff999f63367a952eb93dd10822b7acbbaf315ba03470907b",
-    "libglapi-mesa_18.3.6-2+deb10u1_amd64.deb": "400fa15a8da369359328ad41ac893c4cb51686514ee6a9456dbbfd12e8836ec3",
-    "libgles1_1.1.0-1_amd64.deb": "cc5e1e0f2b0f1f82b5f3c79ae76870e105f132785491efe21fd2d6fd080e25b5",
-    "libgles2-mesa-dev_18.3.6-2+deb10u1_amd64.deb": "eb29ba1d8050688984490cd53e1c6727c7d9cdb79946b0c45dfbbe79aed474c0",
-    "libgles2_1.1.0-1_amd64.deb": "58e9ff1026d81fc38994b12877f6c383e39f599bd98f5c8e5c6bf5716da81a45",
-    "libglib2.0-0_2.58.3-2+deb10u2_amd64.deb": "9b2d2c420beed1bb115b05c7766e981eab3865f9e9509d22fc621389614d2528",
-    "libglib2.0-bin_2.58.3-2+deb10u2_amd64.deb": "306e0cd7d18e7dc6cf19ffea23843ec8f38ebd52f3751b070ef50f88125e531e",
-    "libglib2.0-data_2.58.3-2+deb10u2_all.deb": "19982dfe0de4571ec99f683bd62c74e66c2422a00b0502089247d86c1c08ce92",
-    "libglib2.0-dev-bin_2.58.3-2+deb10u2_amd64.deb": "3066bd946d86fd52b04477a76c7f142243b76b91aa36a146d4488fbc8a1fa907",
-    "libglib2.0-dev_2.58.3-2+deb10u2_amd64.deb": "d83ab43d30e7131f6f893a0ef7a33bc7e9bea9748861dec29c5f29f457e6e1c6",
-    "libglu1-mesa_9.0.0-2.1+b3_amd64.deb": "5eaed67b0a425117601d36a7f2d1d299a45bb6848d1a71d938ae34522deed98d",
-    "libglvnd-core-dev_1.1.0-1_amd64.deb": "2bae9473e270936a87bc4d7756dfb40643c48c77520d9743b0e1ed92f65ba52a",
-    "libglvnd-dev_1.1.0-1_amd64.deb": "60380b7d1919960b453f66155defb341803adb6b5619884c969dfa85fd050fc0",
-    "libglvnd0_1.1.0-1_amd64.deb": "4247b31689649f12d7429f337d038ce73cb8394d7a3a25eac466536a008f00c6",
-    "libglx-mesa0_18.3.6-2+deb10u1_amd64.deb": "0d25475d75cf870387a70afb2809aa79c33c7d05fe333bc9b2e1c4a258489ce7",
-    "libglx0_1.1.0-1_amd64.deb": "cd370a004c0ddec213b34423963e74c98420f08d45c1dec8f4355ff6c0e9d905",
-    "libgme0_0.6.2-1_amd64.deb": "5ca59f1b731b73c06aa9e232ca297e384f2712f691534dd7a539e91788dc3ac0",
-    "libgmp10_6.1.2+dfsg-4_amd64.deb": "d9c9661c7d4d686a82c29d183124adacbefff797f1ef5723d509dbaa2e92a87c",
-    "libgnutls30_3.6.7-4+deb10u2_amd64.deb": "00d35db0d553ba4852546a30b890efb25b6cb565fee5b3d786fe90c5ef6db640",
-    "libgomp1_8.3.0-6_amd64.deb": "909fcd28491d7ebecf44ee2e8d0269b600271b0b6d236b19f2c0469cde162d21",
-    "libgpg-error0_1.35-1_amd64.deb": "996b67baf6b5c6fda0db2df27cce15701b122403d0a7f30e9a1f50d07205450a",
-    "libgphoto2-6_2.5.22-3_amd64.deb": "35971fed6001e039c8512c7bf06a8ffec276a25fd7cf86f4234e45af615f337e",
-    "libgphoto2-dev_2.5.22-3_amd64.deb": "3d7abfbf9b2b288ebcde53b8da27a919d593160847239be5244bee0b8d0c34f3",
-    "libgphoto2-port12_2.5.22-3_amd64.deb": "ff365d9c5350662a78a6e1224febc0fbd173e2abefadc8280499d94b67918940",
-    "libgpm2_1.20.7-5_amd64.deb": "2ff7fbe9078ed8ed9535b4cd8388ed6eb2767e6071a26007383a520e3da0232c",
-    "libgraphite2-3_1.3.13-7_amd64.deb": "f79bfdcfe09285cccee68c070171888b98adbf3e7bd3e8f6afcb6caef5623179",
+    "libavcodec-dev_4.3.3-0+deb11u1_amd64.deb": "53b824799126078fc41c2d764f897bff04d1be6c083d58d88086e645f06995e0",
+    "libavcodec58_4.3.3-0+deb11u1_amd64.deb": "083c47e88d9d1ed2e40e67b5c71e6c24d13527ad504506a8e99d07c7ce502b26",
+    "libavformat-dev_4.3.3-0+deb11u1_amd64.deb": "6c44ad5535658d379e32e5556b6d69389ed65d096ecf6ae0a1486c94232b14e5",
+    "libavformat58_4.3.3-0+deb11u1_amd64.deb": "f23a5d77570bbdb365f0e33900c92733fa469af58862a3e36f9dab76c86815bd",
+    "libavutil-dev_4.3.3-0+deb11u1_amd64.deb": "c9cac2aa74a9ef8c0841a99fc0e17ab5a5e781e0725cc6d65313c9a97e4b8d5b",
+    "libavutil56_4.3.3-0+deb11u1_amd64.deb": "060320302554ed32634deb1708622c9ea8c2919d7f77316e82e97e68fbf0cbbd",
+    "libblas3_3.9.0-3_amd64.deb": "489238f1d2f65dad98d134e5d7fec2a857422d7d2c8af029fc277cff0eec92d7",
+    "libblkid-dev_2.36.1-8+deb11u1_amd64.deb": "3f224b3dc4d094367b45b31c4bc367dd9528f45eba22af77229a7f9be7e6005d",
+    "libblkid1_2.36.1-8+deb11u1_amd64.deb": "9026ddd9f211008531ce6024d5ce042c723e237ecadfbf1f9343cb44aff492b9",
+    "libbluray2_1.2.1-4+deb11u1_amd64.deb": "da902db9e3dcfb7ac7baf723460054012677aefa5a08bcc3fd3f9b1c7a3b58a9",
+    "libbrotli-dev_1.0.9-2+b2_amd64.deb": "520ef8f3af1a190ac2ce5954c0e42c8e6b80a593124f97e813be33e9e068ffc3",
+    "libbrotli1_1.0.9-2+b2_amd64.deb": "65ca7d8b03e9dac09c5d544a89dd52d1aeb74f6a19583d32e4ff5f0c77624c24",
+    "libbs2b0_3.1.0+dfsg-2.2+b1_amd64.deb": "a33848ffed7d42fe0eaa80ebfc3633c4b89f4673971e407ab27ca30638990d63",
+    "libbsd0_0.11.3-1_amd64.deb": "284a7b8dcfcad74770f57360721365317448b38ab773db542bf630e94e60c13e",
+    "libcaca0_0.99.beta19-2.2_amd64.deb": "6d6279c3fcef45cf09c686dff3f9d15d3ef6164ca614b2d019cfc79a10acc9d6",
+    "libcairo-gobject2_1.16.0-5_amd64.deb": "a046d3ca805d4151029941fae736bfdf1c6f3dbcf1bd581102bd5ad844ea013e",
+    "libcairo2_1.16.0-5_amd64.deb": "b27210c0cf7757120e871abeba7de12a5cf94727a2360ecca5eb8e50ca809d12",
+    "libcap2-bin_2.44-1_amd64.deb": "a5b9717d8455cf8517c4c5f29aa04a4dec973430f0d3c1232f652abb9a4d93cc",
+    "libcap2_2.44-1_amd64.deb": "7a3ae3e97d0d403a4c54663c0bb48e9341d98822420a4ab808c6dc8e8474558f",
+    "libcdio19_2.1.0-2_amd64.deb": "1cfcaabed47e58f40742e491493432e815de0fe54e0294e3a2ea2bcbb131ac14",
+    "libcdparanoia0_3.10.2+debian-13.1_amd64.deb": "42afad3ddc60edb9b5f5501ef4870eceaa68e5f8ea3e27edbefdff51c68d6ecf",
+    "libcfitsio9_3.490-3_amd64.deb": "2b3043e9da483e5b06f74c2c2b9d0990f42bed0750e0adb03d95749a8d32212d",
+    "libcharls2_2.2.0+dfsg-2_amd64.deb": "f0a132f0a54e55eeb6db2d74ff669716b633d3b913ccb406766c7d6f7763512e",
+    "libchromaprint1_1.5.0-2_amd64.deb": "adfc5b664f6ec6f60d76bd41546141914bb5d7c797e5291565305d7c293c0827",
+    "libcodec2-0.9_0.9.2-4_amd64.deb": "27b8f890e7b614ea203826b8ecdff65d742993f1bccb15b22e7ae2683e76ec1e",
+    "libcolord2_1.4.5-3_amd64.deb": "b7f0b90535a04f25f4fe8a838b548eed87447b3225414bd4f30755ee917698dd",
+    "libcups2_2.3.3op2-3+deb11u1_amd64.deb": "b9545555975d3560612a44b23c362a03be517a75ddfa7a63bf828e03c57be37c",
+    "libcurl3-gnutls_7.74.0-1.3+deb11u1_amd64.deb": "86ee8f307582708132806c687e0127375d4a42e23d2bf2c96054a547cadddd80",
+    "libcurl4_7.74.0-1.3+deb11u1_amd64.deb": "6f9c494eecc920899bb2c72d1a507a34b3703105778b0b9b9ae9aebdbdffcaab",
+    "libdap27_3.20.7-6_amd64.deb": "fd6436efe71e465fac68acc00911d34e0eed8c5c0627c3f2d0de3bcc9edcb24b",
+    "libdapclient6v5_3.20.7-6_amd64.deb": "1f30f21e55069d28c49dbcff8cab9af71f785565486ad840d86a95674b0ba587",
+    "libdatrie1_0.2.13-1_amd64.deb": "3544f2cf26039fade9c7e7297dde1458b8386442c3b0fc26fdf10127433341c1",
+    "libdav1d4_0.7.1-3_amd64.deb": "f351142dc854dfada4d24ca173f62382e3e24901fe560be6c3fe4515c36858e5",
+    "libdb5.3_5.3.28+dfsg1-0.8_amd64.deb": "00b9e63e287f45300d4a4f59b6b88e25918443c932ae3e5845d5761ae193c530",
+    "libdbus-1-3_1.12.20-2_amd64.deb": "7256dfeda88461e6fccbf98372d3ec29487b3b2d0ae5d145a3332ab35274f0da",
+    "libdc1394-25_2.2.6-3_amd64.deb": "bfc3b2c124393b1045e709ceb96827ad1a45cfce4ebc111bd75457ea5bd43964",
+    "libdc1394-dev_2.2.6-3_amd64.deb": "f435440dd8408eebe554a47f1388396b514c83f40b3f74d9098ec3b65efcb814",
+    "libdca0_0.0.7-2_amd64.deb": "3d3258fc5e8d94c4dbf078b0e4fc4194cf9c7cb069a3a4bb237e894cd6c0afd8",
+    "libdconf1_0.38.0-2_amd64.deb": "ff3b1d05466782acd6e335b001460b7af4ea76f49bbbbd5447535d2b702fa97e",
+    "libde265-0_1.0.8-1_amd64.deb": "82b2f1e53b7e23ead6e375fc12c979fee63d2cdce9a3054fe1177403da86a7fd",
+    "libdeflate-dev_1.7-1_amd64.deb": "fc95c11795f2efd14b59db87214929879c5019bb1af3e77925019c39a57cffa4",
+    "libdeflate0_1.7-1_amd64.deb": "dadaf0d28360f6eb21ad389b2e0f12f8709c9de539b28de9c11d7ec7043dec95",
+    "libdouble-conversion3_3.1.5-6.1_amd64.deb": "0a22f1cca233c2347320d56c65312caafb99e379c1aa48af6164a8905ce34672",
+    "libdpkg-perl_1.20.9_all.deb": "134bd00e60fa30d39d5f676d306d6f1d61c7f6ec6086c1785dbc355ce6190f29",
+    "libdrm-amdgpu1_2.4.104-1_amd64.deb": "0005f21e342925bd26a25185289ae035aa931ced8f6fd9e3d4deade36d272ecd",
+    "libdrm-common_2.4.104-1_all.deb": "60c69026fb8e4cfdf8d80a4a86ee30516c611dcc4de4aa1c8ccbf06dff563e2b",
+    "libdrm-dev_2.4.104-1_amd64.deb": "426033d284eb582ed7c87b7bf9083ccbb6b239a8983e1f930f33b097b96f7745",
+    "libdrm-intel1_2.4.104-1_amd64.deb": "7d376adc7b5d4d83ec8414ff67dbc18765c6d420de9a6e1045fead7f1f82331d",
+    "libdrm-nouveau2_2.4.104-1_amd64.deb": "dbf4a3be55c609b1a2ea89d6782ae5c9a5b991844917dcd42c01666b73a96ceb",
+    "libdrm-radeon1_2.4.104-1_amd64.deb": "c33cd14e8ed7e2dfc02696ed51d4795c5797b0821666667e0a889bba705862b0",
+    "libdrm2_2.4.104-1_amd64.deb": "113396b3a33000f7f3347cd711ad9bcfe9945927331cc6cee63c751a889a967b",
+    "libdv4_1.0.0-13_amd64.deb": "fa10de9781070b1fc16a9b3686175b9458a828300a3ef6c5b8b28f0045cca17b",
+    "libdvdnav4_6.1.0-1+b1_amd64.deb": "ad5b916c9a373db577827d556827f14e4c17df18b0a56a86654bd4caef3bf37a",
+    "libdvdread8_6.1.1-2_amd64.deb": "5b60fa255ab26171b6faddbc97079653cc04e38b58f07cf14069cfff6d5753b6",
+    "libdw-dev_0.183-1_amd64.deb": "f18363d346023f7560c4d588dbddbf18415b8e9f5cd8f0c3f786c84992b7cf61",
+    "libdw1_0.183-1_amd64.deb": "0ee89e2143356239975e6808ea005de396f8e8e0d771e1376c8bc93e29f07ec8",
+    "libedit2_3.1-20191231-2+b1_amd64.deb": "ac545f6ad10ba791aca24b09255ad1d6d943e6bc7c5511d5998e104aee51c943",
+    "libegl-dev_1.3.2-1_amd64.deb": "2847662b23487d5b1e467bca8cc8753baa880f794744a9b492c978bd5514b286",
+    "libegl-mesa0_20.3.5-1_amd64.deb": "a0c36a3665af89cbc96f865bd1b64c6c07b93096e91ba5b470d375d02dfa6d82",
+    "libegl1_1.3.2-1_amd64.deb": "3a5583ebd7a9d8ad102484db9637c409561428d21345037b310c4ef2ca8e8837",
+    "libelf-dev_0.183-1_amd64.deb": "9b711a3a40b65a3ab435509bc0608d3ac3526744ad9ccbc28cad38e8bce794db",
+    "libelf1_0.183-1_amd64.deb": "e1ad132d502b255023c222d0cae1d02ca941f6b68fd0e9b908c6004cc326592c",
+    "libepoxy0_1.5.5-1_amd64.deb": "3d050c9b138872c83b5b3521c97ab89f8a885b1391fdd0477cf8168ae54728a3",
+    "libepsilon1_0.9.2+dfsg-5_amd64.deb": "18f3c005d4f0d71bd8a448a2fe26867301f9cfd87197c455f30b879376e89703",
+    "libexif-dev_0.6.22-3_amd64.deb": "7c89f9dfad3c52c0b1e8e6944b606ebe443f606a1074ce10fa4b49b58a3d304f",
+    "libexif12_0.6.22-3_amd64.deb": "8ea5b829490f9afeeeb8ffa3191e4c8075250465420435f53a007a0a7cbf4f33",
+    "libexpat1_2.2.10-2+deb11u3_amd64.deb": "e3069628af14657a2fb2cc597c35982bf71d392ccf4e70207c92b156a0e341f5",
+    "libfaad2_2.10.0-1_amd64.deb": "b6e9c9d97e4683a0c0173e43a32b682b8454b4b8e07282516c258664a33253e3",
+    "libffi-dev_3.3-6_amd64.deb": "ca2c71d9c68b1944b689606f12acf8023bad1b5083e8413894fd41ad0b977d20",
+    "libffi7_3.3-6_amd64.deb": "30ca89bfddae5fa6e0a2a044f22b6e50cd17c4bc6bc850c579819aeab7101f0f",
+    "libflac8_1.3.3-2+deb11u1_amd64.deb": "7672e1cbd80dfed5bfa572221f061e61b6d84479ba12dc5825145216fbc01de0",
+    "libflite1_2.2-2_amd64.deb": "39e57480254f4de8a53c46b7d143b727d73404ea76e1670727e95d2ce902eb60",
+    "libfluidsynth2_2.1.7-1.1_amd64.deb": "72a881f542ca6125c4ca2313fd2d3c340471b7d6bfbaf6702138bc9f73278ffc",
+    "libfontconfig1_2.13.1-4.2_amd64.deb": "b92861827627a76e74d6f447a5577d039ef2f95da18af1f29aa98fb96baea4c1",
+    "libfreeaptx0_0.1.1-1_amd64.deb": "4f0c5c9198358cffbe40139fc36211b5b6d83804be9985558cce07c61d9f9983",
+    "libfreetype6_2.10.4+dfsg-1_amd64.deb": "e95396fc3cc806b2b95d9a00b4226eb464bc3ef4817c798749a0dd582546e5bc",
+    "libfreexl1_1.0.6-1_amd64.deb": "36a962b167b1971f89568feccabe4b027f177fcab4cbf9a1ed66a03d25a161ed",
+    "libfribidi0_1.0.8-2_amd64.deb": "fa4c6ea0d4d4709b2414a9d9567a3f9d35cd8a270c8dcc8bd79d046fc200b914",
+    "libfyba0_4.1.1-7_amd64.deb": "4ea6e4170eca7ed2a1319c1d1a35f661421f4879de01eafaaff15d10b036b753",
+    "libgbm-dev_20.3.5-1_amd64.deb": "47d53d5959ef7a6c326c8487db7b33911718616e7d9832f2793691ed4458fb03",
+    "libgbm1_20.3.5-1_amd64.deb": "2d9b07282e46e3c9398613b6d4fe86c3259e4326b158be7e1f4f58cab541156c",
+    "libgcc-s1_10.2.1-6_amd64.deb": "e478f2709d8474165bb664de42e16950c391f30eaa55bc9b3573281d83a29daf",
+    "libgcrypt20_1.8.7-6_amd64.deb": "7a2e0eef8e0c37f03f3a5fcf7102a2e3dc70ba987f696ab71949f9abf36f35ef",
+    "libgd3_2.3.0-2_amd64.deb": "fadaa01272200dcaa476c6b8908e1faa93d6840610beca909099647829f3fdc1",
+    "libgdal28_3.2.2+dfsg-2+deb11u1_amd64.deb": "60466068ca138408812696a64a4d6936ab9d84a991125289db50d8e0697d6cd9",
+    "libgdcm-dev_3.0.8-2_amd64.deb": "4c3b97566041cecf408218c76a7b89350bcbcd81a58f6cfcaff45dda4ad37eba",
+    "libgdcm3.0_3.0.8-2_amd64.deb": "6c67f5e4f1bcfbdbfa7a76f45d0d846d6e53a2f39f91c2941614ff0a3d54e86c",
+    "libgdk-pixbuf-2.0-0_2.42.2+dfsg-1_amd64.deb": "2dd0745a0dde7f6afb97a8ea0a30ce266c34d4f11b023e096437a8cd862f4595",
+    "libgdk-pixbuf2.0-common_2.42.2+dfsg-1_all.deb": "61ff764860dafbd7e3fe2050b9c17db3ae109dea15ac748212eff56fdb3111e1",
+    "libgeos-3.9.0_3.9.0-1_amd64.deb": "c6190966a2410f01f14ce5265e362ba77fdf8c25f3b08b5af71ee05f8d70b09e",
+    "libgeos-c1v5_3.9.0-1_amd64.deb": "88072c56bf83ab01f97096fac8b8acdfdad7122c01dcb9fd9825ef4ac525d3fe",
+    "libgeotiff5_1.6.0-1_amd64.deb": "db80978d150545a90db7b18ab4b7681337dcc69b05ce4b7f3d719db2421cf8cd",
+    "libgfortran5_10.2.1-6_amd64.deb": "6fe41d04ea9ef8c5c684b14585caa7a4a7e04ad6805d59cdd29016960b737123",
+    "libgif7_5.1.9-2_amd64.deb": "d06bd6cb48aa985c0a62948579364fb74c9f9fc85eaf1948faa27035bde0078d",
+    "libgirepository-1.0-1_1.66.1-1+b1_amd64.deb": "787e913bf56f19bc54720c3463ab8afe1cc9442536fde31e2a36afc3939f28c9",
+    "libgl-dev_1.3.2-1_amd64.deb": "a6487873f2706bbabf9346cdb190f47f23a1464f31cecf92c363bac37c342f2f",
+    "libgl1-mesa-dri_20.3.5-1_amd64.deb": "08e8bc20077e188da7061f77d23a336782d8463c0cc112fabbfa9c8b45923fd2",
+    "libgl1_1.3.2-1_amd64.deb": "f300f9610b5f05f1ce566c4095f1bf2170e512ac5d201c40d895b8fce29dec98",
+    "libgl2ps1.4_1.4.2+dfsg1-1_amd64.deb": "c2ed4834c4406d26a0381272f60d04ec36bfe0a770b55f104785c04489106432",
+    "libglapi-mesa_20.3.5-1_amd64.deb": "aa8f8eaf13224cbb8729416be79350460f7f2230193b2da5d5e24f3dc7e9985f",
+    "libgles-dev_1.3.2-1_amd64.deb": "969e9197d8b8a36780f9b5d86f7c3066cdfef9dd7cdc3aee59a1870415c53578",
+    "libgles1_1.3.2-1_amd64.deb": "18425a2558be1de779c7c71ce780b133381f0db594a901839c6ae3d8e3f3c966",
+    "libgles2_1.3.2-1_amd64.deb": "367116f5e3b3a003a80203848b5ce1401451a67c2b2b9d6a383efc91badb0724",
+    "libglew2.1_2.1.0-4+b1_amd64.deb": "5be1139eb2f3156f64788d4beee7569e15741b9478c842165df540ecb578bbef",
+    "libglib2.0-0_2.66.8-1_amd64.deb": "995469490dcc8f667df8051a39dd5abd7149d849456c28af4e58cbfd6d6dc4f8",
+    "libglib2.0-bin_2.66.8-1_amd64.deb": "5adf4c916832ad4203fed68faacd4552361cbccc22f66f4504a7ad6fc955bddd",
+    "libglib2.0-data_2.66.8-1_all.deb": "be41a674336cefd00e2a468fe19c8bbf9f3fac86f39379e1b7acbad41f6af644",
+    "libglib2.0-dev-bin_2.66.8-1_amd64.deb": "2dbca7691d2b43545d7a89bafb4cc92a5e42c68085fa4d8989e74b1f5250f9c6",
+    "libglib2.0-dev_2.66.8-1_amd64.deb": "782fcfd549266048309b8da556377c16445bafe9f0aec31d9f246ac9b736d2aa",
+    "libglvnd0_1.3.2-1_amd64.deb": "52a4464d181949f5ed8f7e55cca67ba2739f019e93fcfa9d14e8d65efe98fffc",
+    "libglx-dev_1.3.2-1_amd64.deb": "5a50549948bc4363eab32b1083dad2165402c3628f2ee85e9a32563228cc61c1",
+    "libglx-mesa0_20.3.5-1_amd64.deb": "2d19e2addfbea965220e62f512318351f12bdfe7e180f265f00d0f2834a77833",
+    "libglx0_1.3.2-1_amd64.deb": "cb642200f7e28e6dbb4075110a0b441880eeec35c8a00a2198c59c53309e5e17",
+    "libgme0_0.6.3-2_amd64.deb": "b1885f1cbe610638da6405941abac10f1ec464ff4851c422c4a7ace30cdd259e",
+    "libgmp10_6.2.1+dfsg-1+deb11u1_amd64.deb": "fc117ccb084a98d25021f7e01e4dfedd414fa2118fdd1e27d2d801d7248aebbc",
+    "libgnutls30_3.7.1-5_amd64.deb": "20b0189b72ad4c791cf5b280c111d41ce071a04dab0e9a9d7daa9504a7a7b543",
+    "libgomp1_10.2.1-6_amd64.deb": "4530c95aefa48e33fd8cf4acbe5c4b559dbe7bdf4c56469986c83a203982cef1",
+    "libgpg-error0_1.38-2_amd64.deb": "16a507fb20cc58b5a524a0dc254a9cb1df02e1ce758a2d8abde0bc4a3c9b7c26",
+    "libgphoto2-6_2.5.27-1_amd64.deb": "af72ea52bd64c83ff9723347818c4532490961c4d48d11d3b5da8b77011e815c",
+    "libgphoto2-dev_2.5.27-1_amd64.deb": "745358ca7b96c6897e852f8213743b1aa04c24b799a319671db11c8a56a876ae",
+    "libgphoto2-port12_2.5.27-1_amd64.deb": "8b91bf19afe0523d5856b2bee76e7b9f02481d617c4729bb7adda27233d77146",
+    "libgpm2_1.20.7-8_amd64.deb": "8c6f58b2f0592fdc9d29abc979d3ff47f2c449e20c4f1b326f84165a86115c7b",
+    "libgraphite2-3_1.3.14-1_amd64.deb": "31113b9e20c89d3b923da0540d6f30535b8d14f32e5904de89e34537fa87d59a",
     "libgsm1_1.0.18-2_amd64.deb": "a763da85a8d66c222a74edeb0a58abca813eae02d5bf53b09159869c104817eb",
-    "libgssapi-krb5-2_1.17-3_amd64.deb": "49a2e7f290ab0006dbc139bfe6784f71bf38d1b14feebc22c14808bbe3748f6d",
-    "libgssdp-1.0-3_1.0.2-4_amd64.deb": "573f3c556d56747cccb88b8d4293997557176306ea3378670be541cc123be425",
-    "libgstreamer-gl1.0-0_1.14.4-2_amd64.deb": "41b702e8700a87daafdc7758bb1e4c43849babf36d982bbfec79e0585f023c64",
-    "libgstreamer-opencv1.0-0_1.14.4-1+b1_amd64.deb": "85564c3087b0ae3c30d48ef688e67a67383e33c150b3b8e0538aa3c129f141e2",
-    "libgstreamer-plugins-bad1.0-0_1.14.4-1+b1_amd64.deb": "d85e3ba9dc98b212f3cdc2581ee077abb72c67b6f7fa77932d6c35045126da45",
-    "libgstreamer-plugins-bad1.0-dev_1.14.4-1+b1_amd64.deb": "9d91289a04c31aa89c232595ab4f3e4c27d13956195d9f165e287d262d8177e6",
-    "libgstreamer-plugins-base1.0-0_1.14.4-2_amd64.deb": "be0fea48d5ff9bc178d0af25f9b8cf4dbc9cd915368ea79c848e636d46c6b85a",
-    "libgstreamer-plugins-base1.0-dev_1.14.4-2_amd64.deb": "b4fa8fb012ce3db5179e0ccab722770b607524450cbb380372b7150e75a096c8",
-    "libgstreamer1.0-0_1.14.4-1_amd64.deb": "b12567b65cd1dd951845d7d441ef383b0f1a22756b7a203032d548d0619226ef",
-    "libgstreamer1.0-dev_1.14.4-1_amd64.deb": "0b4a50310a1f042ed1f29c40a6ba857292dccef930a15594a6dc0fd2f98c3aec",
-    "libgtk-3-0_3.24.5-1_amd64.deb": "e652e04b04cc8a67c24c5773180a7fdd65a6cfc55a2777722e80825a56a33729",
-    "libgtk-3-common_3.24.5-1_all.deb": "1e1c979ec882542ce09b40c0f7246a7f348b42d9bec6f31eb2614a8ddccd4874",
-    "libgudev-1.0-0_232-2_amd64.deb": "e7d198d67d0d29a482f0f88a7f2480a4696e1d3ee0612a7ca6be22e6866ea26c",
-    "libgupnp-1.0-4_1.0.3-3_amd64.deb": "d316a0e47251ce5d69bad9c0e3292a4cf6d859a783d618715b9b04e434becdf4",
-    "libgupnp-igd-1.0-4_0.2.5-3_amd64.deb": "4478c4fa1f9f0e44b7a34c8ec389738936127fe5204269d50c923afc471580c8",
-    "libharfbuzz0b_2.3.1-1_amd64.deb": "aee1dd6f9884c1acdd1b6d6f49bd419235decd00f49cd927e4be4c37af2ecdab",
-    "libhdf4-0-alt_4.2.13-4_amd64.deb": "4884c473170273a3cf0e83ec0cb2f1a907c5bbe57b998f0240d5e6aecf20a398",
-    "libhdf5-103_1.10.4+repack-10_amd64.deb": "1236ee56593adf5f06ea6e407d5d7d77c782b9b4c71cada16fe2b867c95f8cd7",
-    "libhdf5-openmpi-103_1.10.4+repack-10_amd64.deb": "9b96bdec653349fd89f4cb6b17fd835b3fb0d0924b9b8e9b9d6346a53d2e567c",
-    "libhogweed4_3.4.1-1_amd64.deb": "a938f22b6cead37c5f980a59330e71e2df1df4af890ea6b3432485c0da96ea58",
-    "libhwloc-plugins_1.11.12-3_amd64.deb": "eb1dc47ac594f102005a8614413adebad0ae56d68785aac6773a05c81c8e1afc",
-    "libhwloc5_1.11.12-3_amd64.deb": "4306a4cfbaf3db358120ba57720cf1c90c512c4aa4e0c1b72f142ac93883bbd8",
-    "libibverbs1_22.1-1_amd64.deb": "681dbe4dafb9dec6ce0d3c987a11bd166babefac91aaf32142defcba394f8981",
-    "libice6_1.0.9-2_amd64.deb": "5ab658c7efc05094b69f6d0950486a70df617305fab10983b7d885ab0a750f21",
-    "libicu63_63.1-6_amd64.deb": "ccf205dfb840a9cdf8d4775febb32ac9bf08e17735920d91f5c39a9cf9c642c5",
-    "libidn2-0_2.0.5-1+deb10u1_amd64.deb": "13c3129c4930cd8b1255dbc5da7068c036f217218d1017634b83847a659fad16",
-    "libiec61883-0_1.2.0-3_amd64.deb": "b31c37a0b954f0aac8e93667b2023a3f399d115d2a91ec02bea0a862ac0cdc34",
-    "libilmbase-dev_2.2.1-2_amd64.deb": "2060c2aec18a71728f4e0abf4b8918771d2dc55e680660ed4f2a7bacd49d3de0",
-    "libilmbase23_2.2.1-2_amd64.deb": "4e0e265a1eb33cc6e6cfcb15581604df4fe252b73b7a353ed2cfe15505fbdbd3",
-    "libjack-jackd2-0_1.9.12~dfsg-2_amd64.deb": "4d9aaaa070e00def2944cb4fe06a6442e4ceb983c27b1f1745467f13b924ca33",
+    "libgssdp-1.2-0_1.2.3-2_amd64.deb": "4ba9103e78206e8af81acd1f2ee7df72befca2080b1106ac410efbdbc5899b4d",
+    "libgstreamer-gl1.0-0_1.20.1-1~bpo11+1_amd64.deb": "5f5a53e3d69b3427d53c0375dd29c651ea37483324053d655e474c516f7fa28d",
+    "libgstreamer-opencv1.0-0_1.20.1-1~bpo11+1_amd64.deb": "98f850c9769edfb3e7258e6bd7b95cba9765ca145447862b4c148f272dcda37f",
+    "libgstreamer-plugins-bad1.0-0_1.20.1-1~bpo11+1_amd64.deb": "2de084e17216c85b9bdf63cd5c3b6f41cdb09612fa641529c217d3f519feae86",
+    "libgstreamer-plugins-bad1.0-dev_1.20.1-1~bpo11+1_amd64.deb": "ee929a14bb78e653d67eeb3156f13d09e52d22f2c25e0cdee29516a4e079fd12",
+    "libgstreamer-plugins-base1.0-0_1.20.1-1~bpo11+1_amd64.deb": "9d2cce1ceacb579a86f74fe21af570c6120b9bbe6b4a2bc242c0e05059b22512",
+    "libgstreamer-plugins-base1.0-dev_1.20.1-1~bpo11+1_amd64.deb": "abee0ed15570032446f36c5c5cd2ff92bf88a5b239d345924a8f4a5212b68f4b",
+    "libgstreamer1.0-0_1.20.1-1~bpo11+1_amd64.deb": "e3b58e3432a7987ec17b748357bb7f50318d17ef69a71d73620c77721007c1f3",
+    "libgstreamer1.0-dev_1.20.1-1~bpo11+1_amd64.deb": "e125c4f47a825385dacff179d823a3b1a478d4ad81b4cd9505539db06501b377",
+    "libgtk-3-0_3.24.24-4+deb11u2_amd64.deb": "f58fcba87f2b7cb03a0f9f174817cc2ef18cd5dcfe41129b618ec3b7d5e0f8a0",
+    "libgtk-3-common_3.24.24-4+deb11u2_all.deb": "172d01f359af8f13cee93dba183e282ea5f059f2a418dfe66d35abf9dd60ddd7",
+    "libgudev-1.0-0_234-1_amd64.deb": "9ec44c4018ed498e871eed85150e5fe557a7fae21f2b5b3d014a0c27be1eaaee",
+    "libgudev-1.0-dev_234-1_amd64.deb": "6c3638cc06781eb697a70d249e6c2b961fc2c2069c7d2d86215c4efe823b0198",
+    "libgupnp-1.2-0_1.2.4-1_amd64.deb": "04737f47c939bc47dbb2ba3ae6914c8528f2319d8275f6ff59c7565db26d4293",
+    "libgupnp-igd-1.0-4_1.2.0-1_amd64.deb": "eae9f92c0591512db92b7bf8b6b13c1084c117a11cd0ade7accce14db4b40db0",
+    "libharfbuzz0b_2.7.4-1_amd64.deb": "c76825341b5877240ff2511a376844a50ffda19d9d019ae65a5b3a97f9a1a183",
+    "libhdf4-0-alt_4.2.15-3_amd64.deb": "43d6a68b0eda21cc1493bf34147317248a35646f97d0192f8e3613287a229e32",
+    "libhdf5-103-1_1.10.6+repack-4+deb11u1_amd64.deb": "ddf76cacf5410bc1e0abe69ed73a56b3be2049f61850a419a0fd4b3479795bd0",
+    "libhdf5-hl-100_1.10.6+repack-4+deb11u1_amd64.deb": "91f0ca7be710a43e9e7a82b8fe4e28387bee103ff64412c7e690f6b27152f922",
+    "libheif1_1.11.0-1_amd64.deb": "79405f9eca217388fd97c4a64557d395f365ad40b412174cae96eb0e5d6738c8",
+    "libhogweed6_3.7.3-1_amd64.deb": "6aab2e892cdb2dfba45707601bc6c3b19aa228f70ae5841017f14c3b0ca3d22f",
+    "libicu-dev_67.1-7_amd64.deb": "7932a6acfbfd76e1dbedcf171dafda9e549b8dc179a666043dbb3d5b733c4a29",
+    "libicu67_67.1-7_amd64.deb": "2bf5c46254f527865bfd6368e1120908755fa57d83634bd7d316c9b3cfd57303",
+    "libidn2-0_2.3.0-5_amd64.deb": "cb80cd769171537bafbb4a16c12ec427065795946b3415781bc9792e92d60b59",
+    "libiec61883-0_1.2.0-4_amd64.deb": "969542c1780f350578b8ed30aaeb770eaa1c714ebdf0fef865691e24ce064ee5",
+    "libilmbase-dev_2.5.4-1_amd64.deb": "a3062a15de35e0ea661a1ccf8bdd85609e17959c495ae9d14967a026f91fa7e7",
+    "libilmbase25_2.5.4-1_amd64.deb": "54b96a6eec874273fedfcd11e2af695a91830a18b3587ac0d7a68e115a82dc2a",
+    "libinstpatch-1.0-2_1.1.6-1_amd64.deb": "47741d5f3efd902515dcf2adfb006c74698d14a91691e16527632299e810208a",
+    "libjack-jackd2-0_1.9.17~dfsg-1_amd64.deb": "2526227a109b4b078cb9483dcab20574d946f9f4bed8b4249d93f8c04d4be22c",
     "libjbig-dev_2.1-3.1+b2_amd64.deb": "6ca760f67d2f482d269d4e1d4cfc5f9c5f7247afb012266db40e773a63ef7048",
     "libjbig0_2.1-3.1+b2_amd64.deb": "9646d69eefce505407bf0437ea12fb7c2d47a3fd4434720ba46b642b6dcfd80f",
-    "libjpeg-dev_1.5.2-2_all.deb": "71b42025bdeb9fcc30054b54c84c4306da59466fbd419f46471f15ec54d435aa",
-    "libjpeg62-turbo-dev_1.5.2-2+b1_amd64.deb": "26f02e34181d7d76d3bdf932444f3f003690e3b8ddbec2ce0617f3ca7c8afd66",
-    "libjpeg62-turbo_1.5.2-2+b1_amd64.deb": "19fa4d492c59e051f00334b1a13bcd3579b3c199623a23e68476cb46d5b1d590",
-    "libjson-c3_0.12.1+ds-2_amd64.deb": "5b0194dac67efa04ef6df15e3080bd53448b0209f6cf25ff6a46c6ba8dccc354",
-    "libjson-glib-1.0-0_1.4.4-2_amd64.deb": "58f872df6bc521a7ef4990c2a4b3264b1a1fab15440297a7e92ef88067e308ed",
-    "libjson-glib-1.0-common_1.4.4-2_all.deb": "c27dbb0cf9c73e2a09d5c774fb46ecf6d2b634facaf3b37b20a4654d9c549187",
-    "libjsoncpp1_1.7.4-3_amd64.deb": "c0467781913f8a59e60b63efcbf334f17058128076c1b265803d98e9e93815cd",
-    "libk5crypto3_1.17-3_amd64.deb": "b9ded0026e9d0e006eb6d3e697919d9b2a8f7bf607d8acdebf03588e2b96b771",
-    "libkeyutils1_1.6-6_amd64.deb": "0c199af9431db289ba5b34a4f21e30a4f1b6c5305203da9298096fce1cdcdb97",
-    "libkmlbase1_1.3.0-7_amd64.deb": "6bd25218052f42b46c85d20dec2ecddc40cf31be51177b82b8e848a0063abe64",
-    "libkmlconvenience1_1.3.0-7_amd64.deb": "c473db7982aaa5bd51abd50b7c59b7d7ad38a03a2a077ef3bf6b70393388d8c5",
-    "libkmldom1_1.3.0-7_amd64.deb": "a2c279ba0354dba90ca8a7a3f53b4880f3bfbc309b52bd97f78a2e2be11b3ff6",
-    "libkmlengine1_1.3.0-7_amd64.deb": "926353a83536421f6a8edcfc5530c1be7dd62f0a202ae6978d7aeeb8bb22d7b7",
-    "libkmlregionator1_1.3.0-7_amd64.deb": "d7f211d0443aae8648f4e5320815f23a6d3efa26041b69d3e66fe1a3a5d98f3d",
-    "libkmlxsd1_1.3.0-7_amd64.deb": "f6fed1c2774053cb41bde7fe7ae631999af226b24ac8cb904b5e1a3bd3efc097",
-    "libkrb5-3_1.17-3_amd64.deb": "042967b8267ee537ed9a1bf012533622847aab433362e3b57c9108a53bfcb99a",
-    "libkrb5support0_1.17-3_amd64.deb": "e0e9d331643755db339e321c38889be13a8284cbba8ed0b7bfc062f8a68a0974",
-    "liblapack3_3.8.0-2_amd64.deb": "29f7df1fb03bc42b38872d37f2d1fc43ac0943b117dd766d8771247363ab4419",
-    "liblcms2-2_2.9-3_amd64.deb": "6dd806a326519b98ed9e54b184b4da2d256c4d516e75d0a38f2f6059e14eb325",
-    "libldap-2.4-2_2.4.47+dfsg-3+deb10u1_amd64.deb": "780b7e3f4d5780a705bf5bbb6b3d1d7e93cb822e831ec4a3d0da5ffd6fc39c40",
-    "libldap-common_2.4.47+dfsg-3+deb10u1_all.deb": "ee6a95d9e8a88de8770b9279239ba7bcdc754edab7b06220d960ba6eb3aaf306",
-    "liblept5_1.76.0-1_amd64.deb": "fd136eb4907d04382f46bdf75a4fadd8d589a6bd6eb19609c186a1c774cf98ca",
-    "libllvm7_7.0.1-8_amd64.deb": "353d119fd3852c168bafdf73565d4030cdf9c580fd341b3ef9e77e49720bdf30",
-    "libltdl7_2.4.6-9_amd64.deb": "d5fc0ab86db9a6a02c2ad517671788c08cf86cfa0186bac1b5c863b14e2e7eb6",
-    "liblz4-1_1.8.3-1_amd64.deb": "826203ecea7e8cb87aebfbb7bd2afc9f7e519f4c0f578c0404e21416572d1005",
-    "liblzma5_5.2.4-1_amd64.deb": "292dfe85defad3a08cca62beba85e90b0231d16345160f4a66aba96399c85859",
-    "liblzma-dev_5.2.4-1_amd64.deb": "df1c6d0290e42418df9ed76c0e17c507a12bfd590c0a17e580675555e99e51ea",
-    "libmariadb3_10.3.22-0+deb10u1_amd64.deb": "d1ea3bbf04124a8d0aab4541956bd30c8854259fe8d1b761ad1b3107a45ce3c3",
+    "libjpeg-dev_2.0.6-4_amd64.deb": "147a736e2eed59e0a2592436b28c410fd59eb18da5912925160496a8e65560e7",
+    "libjpeg62-turbo-dev_2.0.6-4_amd64.deb": "a3e7ccd1a02c147867e5bf29dd35e16246ad4def19421e73e46fee51fe487baf",
+    "libjpeg62-turbo_2.0.6-4_amd64.deb": "28de780a1605cf501c3a4ebf3e588f5110e814b208548748ab064100c32202ea",
+    "libjson-c5_0.15-2_amd64.deb": "911629a85e4f4bfd426a48e10ad8bca33511cedf1a6c96892fc8a51e04099844",
+    "libjson-glib-1.0-0_1.6.2-1_amd64.deb": "c2db69dda6ceda43065d694c5ebd515900dd38d7231a74016f10a2d2a870f01d",
+    "libjson-glib-1.0-common_1.6.2-1_all.deb": "a938ec35a20dca2e5878a8750fb44683b67a5f7c2d23d383963803a9fcfac1a3",
+    "libjson-glib-dev_1.6.2-1_amd64.deb": "a5fceefa2d7c3e3603cc3f85f5716aeb6b61f5e1d9fc9bd9530d065f2e441d40",
+    "libjsoncpp24_1.9.4-4_amd64.deb": "4e43501e9f43f9c8b28ae1480dec83b6f8ffb565acfdab2016e649caf6b9fe5a",
+    "libkate1_0.4.1-11_amd64.deb": "b23460940c4a88cd4a7430eee889a3f512b5ec89ae253361438e6f2c3569d90c",
+    "libkmlbase1_1.3.0-9_amd64.deb": "1d2a98660a142761aeb64b191bd86b5eff51ff15e05f596874c4abe00a07e9ee",
+    "libkmldom1_1.3.0-9_amd64.deb": "5ecaed0211a0fd7793abdd3963941ed25faf74ab86273a57ff90a75f9aeae7e3",
+    "libkmlengine1_1.3.0-9_amd64.deb": "ab0c0a5a4037f266e691a5faba20fa04aa7f5f82763d8dd61ae9957ef4fbc232",
+    "liblapack3_3.9.0-3_amd64.deb": "7fc4cd55ca777dbe0745bd167abebed0b5d64b5cdff8900fec2ae579859fbade",
+    "liblcms2-2_2.12~rc1-2_amd64.deb": "0608ecb6ed258814e390b52b3fb50f2a6d3239b5ecb1086292ae08be00a67b0f",
+    "libldacbt-enc2_2.0.2.3+git20200429+ed310a0-4_amd64.deb": "142f9848fc3fe8f5ace0878b4619d8b5154ed38ff630bab4ecaf9214cf9652f4",
+    "libldap-2.4-2_2.4.57+dfsg-3_amd64.deb": "4186d0d3f086202d391da49d1bb5ced6dde5eafba1dbcffef9a8e1238a7ef7c3",
+    "liblept5_1.79.0-1.1_amd64.deb": "5fb926add78b22c0290d969cec728741a88ae8e28ba18cc82e7ac0db54b25b48",
+    "liblilv-0-0_0.24.12-2_amd64.deb": "1f33d0d543971296a806e264d14b84f662c35739f6525cf607fe363498520369",
+    "libllvm11_11.0.1-2_amd64.deb": "eaff3c8dd6039af90b8b6bdbf33433e35d8c808a7aa195d0e3800ef5e61affff",
+    "libltc11_1.3.1-1_amd64.deb": "aee63cda707bfd3178a8446f8e2a46b30577df74dd2bc2642f1e9f52515a045b",
+    "libltdl7_2.4.6-15_amd64.deb": "52a0a21e06bb89038a3ab6949020228fbf9dd7897e027233cf0a8c2d111d6c10",
+    "liblz4-1_1.9.3-2_amd64.deb": "79ac6e9ca19c483f2e8effcc3401d723dd9dbb3a4ae324714de802adb21a8117",
+    "liblzma-dev_5.2.5-2_amd64.deb": "dd031326f1dfd774ac94e36bb7afdd06f6ce9b5ce3ee4e25b490ab26898fc2dd",
+    "libmariadb3_10.5.15-0+deb11u1_amd64.deb": "81e470c15a8c1fe476cc92f107a80890566af4aa7d27059cc498e4250e98c00f",
+    "libmd0_1.0.3-3_amd64.deb": "9e425b3c128b69126d95e61998e1b5ef74e862dd1fc953d91eebcc315aea62ea",
+    "libmfx1_21.1.0-1_amd64.deb": "0303163e7fbdfb8e32b6322c6a7c32c01c2d4ad2035e4201b9cf375eeb0e5ef9",
     "libminizip1_1.1-8+b1_amd64.deb": "9141e2d8195e920e1e7a55611b75e4a8cf007f19322432c08c21422574262983",
-    "libmount-dev_2.33.1-0.1_amd64.deb": "d98985a29d705146cddffed1442980549d8bf0d5148fbf03fbc413bdd3aec8ca",
-    "libmount1_2.33.1-0.1_amd64.deb": "b8b28669dc4995a7a48d47d9199d1806d4fce9c4051277279d4dcc514c086ba3",
-    "libmp3lame0_3.100-2+b1_amd64.deb": "9743322c11e89a9c4ca00fc383522ec01d59819c61b126cf9b9690528d348592",
-    "libmpdec2_2.4.2-2_amd64.deb": "9ca85e6e2645a5e660431294320658ec7a2910d9fed90ca4e648c1211a2b844b",
-    "libmpeg2-4_0.5.1-8_amd64.deb": "395454259a0a1bbb94da9dfb50c072909e0699144371866e7f24241504d2359b",
-    "libmpg123-0_1.25.10-2_amd64.deb": "aad76b14331161db35a892d211f892e8ceda7e252a05dca98b51c00ae59d1b33",
-    "libncurses6_6.1+20181013-2+deb10u2_amd64.deb": "25cc6d68d36b13b54ca5a1c2933703681bf4694a66ee29a555616620a482fe0d",
-    "libncursesw6_6.1+20181013-2+deb10u2_amd64.deb": "7dffe9602586300292960f2e3cf4301acfc64a91aed6fa41ea2e719ae75788b3",
-    "libnetcdf-c++4_4.2-11_amd64.deb": "36391f3fd7d4e390366f4abc0f359bc824c60531994544eace2c7c7579b11a22",
-    "libnetcdf13_4.6.2-1_amd64.deb": "70755c490c8f430ff2428872a9d4742098526e3907e19a53fed32fd45bdec571",
-    "libnettle6_3.4.1-1_amd64.deb": "5a384c773ae68b0c7905ecc0abf5e45925794b679674866d7783d88786ffb0d2",
-    "libnghttp2-14_1.36.0-2+deb10u1_amd64.deb": "6980055df5f62aea9a32c6cc44fe231ca66cc9a251b091bd0b7e3274f4ce2a19",
-    "libnice10_0.1.14-1_amd64.deb": "225c4955256cfb8bc74c32e4cd0d136bf02af53914f37d7664044ec0b8853dd7",
-    "libnl-3-200_3.4.0-1_amd64.deb": "4d381ab32378d599b963d6418fc89ca0c7ae7d00277c80e08ac103bae6109ca9",
-    "libnl-route-3-200_3.4.0-1_amd64.deb": "0704ba113c8a3f8b348de8e88f4dc877578c51c194090cea07b869ee3a3fdbc8",
-    "libnspr4_4.20-1_amd64.deb": "e6188fdd91ec215d12d4eca5211c2406874eb17f5b1c09d6355641a349adcec0",
-    "libnss3_3.42.1-1+deb10u2_amd64.deb": "e9a421a3ca17274eb471d55034b13a5845306c55967619d2b1f3c5ee54bfa891",
-    "libnuma1_2.0.12-1_amd64.deb": "ab2277a2af54056f7c2b01f98c0ac9ea546753a35de00e74285b7a0f667ea7e7",
-    "libodbc1_2.3.6-0.1_amd64.deb": "04fd35fe0afe55ef8d0b9523edd569242815b0d7a9f21de1da812c458dd8c2cd",
-    "libogdi3.2_3.2.1+ds-4_amd64.deb": "e3ad75566b51255c04ff96a4c0e19c25ea36b21d679371446bf6c00b1d426f36",
-    "libogg0_1.3.2-1+b1_amd64.deb": "fd8e4b0e1ce171daff480eafd862d8e3f37343dc7adb60a85229f39e45192663",
-    "libopencore-amrnb0_0.1.3-2.1+b2_amd64.deb": "5561b98a6f46ca93950872fcb5a098a4af067e1bf4d1052d9f1c3365ec4d2d07",
-    "libopencore-amrwb0_0.1.3-2.1+b2_amd64.deb": "eb76ef7aecc6fc92077d4da1a00fdadd1109e1bcaedb8fe8fff329e80b9712c3",
-    "libopencv-calib3d-dev_3.2.0+dfsg-6_amd64.deb": "27d9496c13ecdc4e163a956ed27bead3c32c8855eda60061df8613a51631a512",
-    "libopencv-calib3d3.2_3.2.0+dfsg-6_amd64.deb": "82127fc7f416ebe777d418a7ca1971dbd1c5efde739ef0bb4ec45cda64d5f2be",
-    "libopencv-contrib-dev_3.2.0+dfsg-6_amd64.deb": "7d2ea9425942e8fe845912c9ec6566b7aff119a309461b9c31f5ee2765b9286b",
-    "libopencv-contrib3.2_3.2.0+dfsg-6_amd64.deb": "6a9ef938a4e27616556bb70ab12ee23aa703b5a02ab1fa21600811c7f41db762",
-    "libopencv-core-dev_3.2.0+dfsg-6_amd64.deb": "65e19e74938c8e76f9e37ae1112751edd130ab985fb9f7ef0720f6600d7582c6",
-    "libopencv-core3.2_3.2.0+dfsg-6_amd64.deb": "32bdd13bab61af2315b5c5e19989162192a44301f42871c85c988d1a010910d3",
-    "libopencv-dev_3.2.0+dfsg-6_amd64.deb": "39d8a36c3bdcec1218cc2f7db1a11db283b793c864913f9cb53d33d5b383723b",
-    "libopencv-features2d-dev_3.2.0+dfsg-6_amd64.deb": "7cd7d7f8c0fb713a3879413ab9249d0a0ce42065f1a44ab3e2f274aa6a151b39",
-    "libopencv-features2d3.2_3.2.0+dfsg-6_amd64.deb": "30596fcb4998bfd25bfcbe99803bb6622da8523d9585c8b89f75b4b984d26841",
-    "libopencv-flann-dev_3.2.0+dfsg-6_amd64.deb": "823f5ccdac8b5be341724d51bd3462b6c93078dd406cc47bbe2f79f2dc7e804f",
-    "libopencv-flann3.2_3.2.0+dfsg-6_amd64.deb": "8ffceaddd6d8a24d8e0b4869e29a8aff39ef17f943a69862a00562bad2ad1025",
-    "libopencv-highgui-dev_3.2.0+dfsg-6_amd64.deb": "be31c1e23123f05a764436e63f73c693fd33dfc7d2118a8749e92366edcce842",
-    "libopencv-highgui3.2_3.2.0+dfsg-6_amd64.deb": "b4959b56fb3de46f1d5a7b09360558ab2469d2eeee2241090924a5e85bcba06a",
-    "libopencv-imgcodecs-dev_3.2.0+dfsg-6_amd64.deb": "434689bcc78706e97e545e76ea60a876287c6105b5d9848e161a99752cabad75",
-    "libopencv-imgcodecs3.2_3.2.0+dfsg-6_amd64.deb": "cd945a6301c7fd8ce50643392c413cf2d2b870be539fceb5d259c30a571d42c1",
-    "libopencv-imgproc-dev_3.2.0+dfsg-6_amd64.deb": "b85d61d0dca625eab589d22d69132bb4b6c1cf1eb49e4499e576c8e991f7d83c",
-    "libopencv-imgproc3.2_3.2.0+dfsg-6_amd64.deb": "b4e5edf3385d233627a47b97bd1549c27d3c2ac6a9d10c6225a2ea3cb4f84ccd",
-    "libopencv-ml-dev_3.2.0+dfsg-6_amd64.deb": "274de19ab04749d41c9791e2ae5821ff45f437a2d11b516e276f5554f34ca5d8",
-    "libopencv-ml3.2_3.2.0+dfsg-6_amd64.deb": "8399ee0c46d1b0ad6e2dd580255daec319055a51423d8506a833e4e24530b02f",
-    "libopencv-objdetect-dev_3.2.0+dfsg-6_amd64.deb": "deeeefa46c326a0040b414e43df050eb903eb9c847275f0b72cf961c17169f5b",
-    "libopencv-objdetect3.2_3.2.0+dfsg-6_amd64.deb": "1f435a5f2f3cff3c29a8c30cbef0cb53d9dcfc6908e8dea045dc13436821c6cc",
-    "libopencv-photo-dev_3.2.0+dfsg-6_amd64.deb": "764e7aca50104588726843db0e1178aaad2b591d5f1c234fb2302a321123eca5",
-    "libopencv-photo3.2_3.2.0+dfsg-6_amd64.deb": "5f9441de0b3b2d43196763f4027603cbdb7fb44a83c872d8e913560563282e3b",
-    "libopencv-shape-dev_3.2.0+dfsg-6_amd64.deb": "521c63b1f251477238e1ca9e3aae0a3a1cb822fc3f939f958deb2e0111e98275",
-    "libopencv-shape3.2_3.2.0+dfsg-6_amd64.deb": "b410c1e5b71dfcee0dff145a9c6a91532f4c56d62a363da4ae5cf8fd8eb223b0",
-    "libopencv-stitching-dev_3.2.0+dfsg-6_amd64.deb": "3a440bd217e48166b875b298ea554e730716814bc465b8dc3f80f6c950de8551",
-    "libopencv-stitching3.2_3.2.0+dfsg-6_amd64.deb": "e754dc2df8a3381839dd6378d387542898d55a2b7b64869fbc604686e150f704",
-    "libopencv-superres-dev_3.2.0+dfsg-6_amd64.deb": "fd5bedfac07e4b68949e988c89e192b33ccc863407944706faad0a72963b84cf",
-    "libopencv-superres3.2_3.2.0+dfsg-6_amd64.deb": "ffdc92dd75005126eb52533d62eaefc4672c8093141340a4e7928e050443d901",
-    "libopencv-ts-dev_3.2.0+dfsg-6_amd64.deb": "0dfd2eef637818eda7d31750c70b015644bc0456783d456baa6cd2ee10a062b2",
-    "libopencv-video-dev_3.2.0+dfsg-6_amd64.deb": "3d1676dcca48cb25769492c0458dc18e7c73dfbc8972bb392752e609e5fae39a",
-    "libopencv-video3.2_3.2.0+dfsg-6_amd64.deb": "28f1b40bda8a0a14c196cd7a81f901fc15c9ee45da10f736da90ccf0b1dbdcbc",
-    "libopencv-videoio-dev_3.2.0+dfsg-6_amd64.deb": "b4d9d179d542dd1472dc40ad6fb7fea3f593b408b16eecab9998f2a33c391da3",
-    "libopencv-videoio3.2_3.2.0+dfsg-6_amd64.deb": "4f2eadcd5ce4bc8d0ab2f58a7762cbfd52f64a101e71ce8be772b598c20e098b",
-    "libopencv-videostab-dev_3.2.0+dfsg-6_amd64.deb": "f2885e518d007a65fc88e5eb97cd2a19d6ed10530d2b025ab835db888329d00a",
-    "libopencv-videostab3.2_3.2.0+dfsg-6_amd64.deb": "290d0ac910701ba468fecc2c8cb2ba82b918c1a51494d7dd902e3b4dde12944c",
-    "libopencv-viz-dev_3.2.0+dfsg-6_amd64.deb": "f9ad9aea38b1684addae5db528d875bdba5865a6cc79df5d2811300248daa781",
-    "libopencv-viz3.2_3.2.0+dfsg-6_amd64.deb": "ac1dc5ef101bd4328fbecec8582c390ccdf54efd7fb7c79391f0c37338cf0c98",
-    "libopencv3.2-java_3.2.0+dfsg-6_all.deb": "6a177762d8dbe7e2a54cfc03aa523802848e0567ded674314d1919652b07f81b",
-    "libopencv3.2-jni_3.2.0+dfsg-6_amd64.deb": "038a30852d113505629350e7c16a13af2f61ffda4118e4b82cf601726adefae3",
-    "libopenexr-dev_2.2.1-4.1_amd64.deb": "bde724ab34b97892ae41e19874bb3f23f650f36df1eaece4d0657f5297f11bea",
-    "libopenexr23_2.2.1-4.1_amd64.deb": "21c7979a6b08b5090fa368b4a933518a158cb242073ba85b7e0ebc22033d199d",
-    "libopengl0_1.1.0-1_amd64.deb": "52db2523f92e299c0002cf73d225c62bad50a54d2e88174176f6310b48b3b67c",
-    "libopenjp2-7_2.3.0-2+deb10u1_amd64.deb": "be133e48ac8894d4824b6106fe361a1b46acbcef8232b3b98dc04455da90e02a",
-    "libopenmpi3_3.1.3-11_amd64.deb": "02db5446521cdbd3833ae483600c8fb6adc555c5f7141480f8a0d287a142cd50",
-    "libopenmpt0_0.4.3-1_amd64.deb": "fa1acaede28cae58f0dbac63ce05743409575cb3eecd621043205c3fb04966ad",
-    "libopus0_1.3-1_amd64.deb": "78d2d72932f9749012cf356e8699f5f56c4a707eeb1f18c44b59928af7ac5876",
-    "liborc-0.4-0_0.4.28-3.1_amd64.deb": "50d46ca045ab1a5a4e17aab20f890b6704297c44019ac4e9ad3bf48498ef69ab",
-    "liborc-0.4-dev-bin_0.4.28-3.1_amd64.deb": "48a5c4dae4bf7c48401a2c414f6854de5eb63dc809e1a5f2fb817980246b6831",
-    "liborc-0.4-dev_0.4.28-3.1_amd64.deb": "05ce2269e6c711368d8fa78a2caaead32468caf406396a76cf9d3b0a75e304db",
-    "libp11-kit0_0.23.15-2_amd64.deb": "4b677eab958f55e5e701c9d8bbdc27f4e7afdb07756a5f8746e97251ee66907b",
-    "libpam-modules-bin_1.3.1-5_amd64.deb": "9ba6ca27c6d4077846c2ec3489c30b8d699391393fa0c0de28a1de8cffbf118e",
-    "libpam-modules_1.3.1-5_amd64.deb": "bc8a1c2e17c0855a3ecef398299d88696ed6d8254cc03cce3800c4a4063f7d7d",
-    "libpam0g_1.3.1-5_amd64.deb": "b480fef838d01dc647170fdbde8d44c12e05e04da989b3bffd44223457cee0dc",
-    "libpango-1.0-0_1.42.4-7~deb10u1_amd64.deb": "2426547312628b7c1585f7043f316271d97fe32d663b1fe5b1afae8d71aa4186",
-    "libpangocairo-1.0-0_1.42.4-7~deb10u1_amd64.deb": "deccaebf49890ae9569ab94b1dbf97dfb84553c71d140d2d493f2984306c5233",
-    "libpangoft2-1.0-0_1.42.4-7~deb10u1_amd64.deb": "31e25bb0553175cb1ae81c89fcf084c6222d9c66b3d801385a25d73c300a21d5",
-    "libpciaccess0_0.14-1_amd64.deb": "5f6cc48ee748200858ab56f43a47534731f5012c2c7c936a364b5c52c0cbe809",
-    "libpcre16-3_8.39-12_amd64.deb": "843e6f8cbe5545582e8f5fcbd4acdc17fafa81a396249381782a0f89ac097f05",
-    "libpcre3_8.39-12_amd64.deb": "5496ea46b812b1a00104fc97b30e13fc5f8f6e9ec128a8ff4fd2d66a80cc6bee",
-    "libpcre3-dev_8.39-12_amd64.deb": "e2b3c3dd3e23a70f9488c31d53c88aae90f84d574b6fdb015dd6de4a9cc853fe",
-    "libpcre32-3_8.39-12_amd64.deb": "7a082633a4288af6cdec0ca2c2b9c908e2d1c3640c0cca4c16890942823fa0ab",
-    "libpcrecpp0v5_8.39-12_amd64.deb": "06b470c5dc5c29600f34b7b9a802ff804644b990a064159487ccde73d0309f13",
-    "libpixman-1-0_0.36.0-1_amd64.deb": "4382ebfc5c52623d917dc0f63c22fbf7a791d00f5b303cd56a44bf9616fa5fbe",
-    "libpmix2_3.1.2-3_amd64.deb": "8bb028cd0e3e2dcb3ed39e68b0e2b15ea757945989201832d671d2be0f9d44b5",
-    "libpng-dev_1.6.36-6_amd64.deb": "43c90b368979af1aaf2baa239892250203b24f1da0814266e009bae0a850763d",
-    "libpng16-16_1.6.36-6_amd64.deb": "82a252478465521cde9d5af473df01ed79f16e912effc5971892a574e9113500",
-    "libpoppler82_0.71.0-5_amd64.deb": "803a32bab6406429fefe53b9502386e2f831a347562eddf490b2a4c5b6fb410f",
-    "libpopt0_1.16-12_amd64.deb": "6eab4706e8f484eefcd708b0fb26a1ae27c01442a6ca2fc1affb0197afbadab1",
-    "libpq5_11.6-0+deb10u1_amd64.deb": "3407ca0dd5fae698d56faa924e735301ea5e5d901282b57400a8135433126801",
-    "libproj13_5.2.0-1_amd64.deb": "8795d816010fe3f940e842b0bf0283ec584587013eb2ace82db6676908f2c114",
-    "libproxy1v5_0.4.15-5_amd64.deb": "0e782aa0488d7effd7c3b937eeed7a604f846093bb7215467177c22bb6471011",
-    "libpsl5_0.20.2-2_amd64.deb": "290fc88e99d21586164d51f8562c3b4c6a3bfabdbb626d91b6541896d76a582b",
-    "libpsm-infinipath1_3.3+20.604758e7-6_amd64.deb": "aa453566f8efa394b7f8d6dba30ba684647f11147cec4fbe0faaa6ebb598425b",
-    "libpsm2-2_11.2.78-1_amd64.deb": "a4cdf6398189d96fbb235e6223b2f3421b1d4605da4a5d482f285491a971e2ff",
+    "libmjpegutils-2.1-0_2.1.0+debian-6_amd64.deb": "bfc822b7393db9c94a862bc896e08678e51465d61c239e57b27c3cd7e39f75c6",
+    "libmodplug1_0.8.9.0-3_amd64.deb": "d91bf3bd1c8fa00ad5f38b4095ff500437de40ce53af8c808c69e931b814c3f2",
+    "libmount-dev_2.36.1-8+deb11u1_amd64.deb": "e2ab59f02398ff5f50d58ba5702a3dc27d47b6b028fccab03d0e8060e317f328",
+    "libmount1_2.36.1-8+deb11u1_amd64.deb": "a3d8673804f32e9716e33111714e250b6f1092770a52e21fab99d0ab4b48c5d9",
+    "libmp3lame0_3.100-3_amd64.deb": "0931247b484e5e3444a3273c96d1e8b719325950610e6a018442843a0cdf56bc",
+    "libmpcdec6_0.1~r495-2_amd64.deb": "21a2e6f591a38df89b148c1584d2ce77dd50303f5b54a9fce0182d6df3510269",
+    "libmpeg2-4_0.5.1-9_amd64.deb": "a8e18dd007804321557611d5e73d55c1502c45c63b63df81d1f64346004f9e16",
+    "libmpeg2encpp-2.1-0_2.1.0+debian-6_amd64.deb": "936d1660078fccf5af2ba6f4be790fe927909ef1d29c0fc79d3416fd27c29c71",
+    "libmpg123-0_1.26.4-1_amd64.deb": "c024421b06a7aa4ef0f817f4360ee36aab0a80546de13cbd71df7233ea14751e",
+    "libmplex2-2.1-0_2.1.0+debian-6_amd64.deb": "ae0de179ccbc07dbba895c9eb335eda7112832d9192ba96dd167202f3deae1b5",
+    "libncurses6_6.2+20201114-2_amd64.deb": "dfe45cb6ab048d1182175df55b007a4a188515c6d764a4dd5a44a0b47b6286a1",
+    "libncursesw6_6.2+20201114-2_amd64.deb": "ee3cd315dfa18865cf888ba6813a552077a4f3d1439dd225e4a0d0fee53aadc2",
+    "libnetcdf18_4.7.4-1_amd64.deb": "b25476561e7380308d6c4c7bb9e8f19dd51ee62705c2615c6aab29ecc882c8d8",
+    "libnettle8_3.7.3-1_amd64.deb": "e4f8ec31ed14518b241eb7b423ad5ed3f4a4e8ac50aae72c9fd475c569582764",
+    "libnghttp2-14_1.43.0-1_amd64.deb": "a1a8aae24ced43025c94a9cb0c0eabfb3fc070785de9ee51c9a3a4fe86f0d11e",
+    "libnice10_0.1.18-2~bpo11+1_amd64.deb": "429745caf0b8590da661bf89c45c586ee59fff4b7d84732b91f516c0449a4063",
+    "libnorm1_1.5.9+dfsg-2_amd64.deb": "a6388c8d460e86c7b76b08e82ecb09894d1d9c53b488850fb39702af85b6d159",
+    "libnspr4_4.29-1_amd64.deb": "adc6d0c181279be9f9e422d54fed41f7134eda4a352e98d028a67c2413e62e3d",
+    "libnss3_3.61-1+deb11u2_amd64.deb": "41c6ceecdbe0067fd6ff99f7f96f52599542f712a1f94173980283b3cacbe30d",
+    "libnuma1_2.0.12-1+b1_amd64.deb": "5a0d21a96ec7a5d50e0c2352ac086dde7dd9cd6018f80f2a74ec6fd4dd47b4bf",
+    "libodbc1_2.3.6-0.1+b1_amd64.deb": "a19d4e2aa8f7d692e0e37f09bd9bd098443468b76b7dbbcc7e1aee0b9eda960e",
+    "libogdi4.1_4.1.0+ds-5_amd64.deb": "315cb60027d9db71d9c15b860263cb33242af2480af6ef90c261372f5c6a5c04",
+    "libogg0_1.3.4-0.1_amd64.deb": "008a385ccb755d85893bda7d3820408c1f92439ea112130d579025cadc0f58b1",
+    "libopenal-data_1.19.1-2_all.deb": "695a650803f885459994bb921132d956c2b693759572005351a5b13773c754cd",
+    "libopenal1_1.19.1-2_amd64.deb": "b027d29d37786e4dacb21a7268e911566efb09f5a20facc66c57dd22a7c31e83",
+    "libopencore-amrnb0_0.1.5-1_amd64.deb": "798c77fb6cc44ff35d88b0113c37a01f40790a739b1b12dbd65a3c67f9b00422",
+    "libopencore-amrwb0_0.1.5-1_amd64.deb": "7a13750aed7953d7c9230236d17b8bd560260b55a63583de099062952ccd8b1a",
+    "libopencv-calib3d-dev_4.5.1+dfsg-5_amd64.deb": "9ed0faf68e3c91e640139ecb7729b8b186bd31f80dcf64612dd769a1cee79957",
+    "libopencv-calib3d4.5_4.5.1+dfsg-5_amd64.deb": "7631eb7412ac953c1a4f31fb2254ef6111bf07a55f8d59d11794d8e31164afac",
+    "libopencv-contrib-dev_4.5.1+dfsg-5_amd64.deb": "66dd52c8fd36fa91afc2bdaa4cfa4403788dd7a40536abe44ed50d120063f3c0",
+    "libopencv-contrib4.5_4.5.1+dfsg-5_amd64.deb": "3148a23d69669b63ef6340cd705eb0caf943541f8687ce8cdb1984ec53f980bc",
+    "libopencv-core-dev_4.5.1+dfsg-5_amd64.deb": "cfefbd5ab57bdd5481bcca3e74a9e8ef699a8feb14e7d1087c8163cdaeb3fe1e",
+    "libopencv-core4.5_4.5.1+dfsg-5_amd64.deb": "2fc53f145d40c0e209f31608f0bca7d358f372be80289e0a2b7e777474e2f714",
+    "libopencv-dev_4.5.1+dfsg-5_amd64.deb": "9b9912b39cea7fc43bfd4a6dbe50769a6d2b6d8378e0ac8a48b90f756436b647",
+    "libopencv-dnn-dev_4.5.1+dfsg-5_amd64.deb": "3861eb39bf7a8cb186a9cd99889a160787d6f342e165c45bcab08f7f5101444f",
+    "libopencv-dnn4.5_4.5.1+dfsg-5_amd64.deb": "741fc61ab0858c50362c0f93f700c3facc350c06362a95780bb772a435f862b0",
+    "libopencv-features2d-dev_4.5.1+dfsg-5_amd64.deb": "7bd49185d9edc346b5331e6651fa4a12eb7066d4d632e28a93b26d63aa263560",
+    "libopencv-features2d4.5_4.5.1+dfsg-5_amd64.deb": "9f34ce569249905b596fc0a6cefca51453abd483ff52b8756170b4e31f7cd129",
+    "libopencv-flann-dev_4.5.1+dfsg-5_amd64.deb": "1a1611a9564472d92aefcdad3f4b1bd6cbe1853fe6206a8c39fecbb95defe02b",
+    "libopencv-flann4.5_4.5.1+dfsg-5_amd64.deb": "46a2ac744124fdee8d7e749fa465ea780ccd155bfb04e6c590bf09e2e6396728",
+    "libopencv-highgui-dev_4.5.1+dfsg-5_amd64.deb": "ec710ccae408b9087ae88591ea525c032bfb51af61c47d065a3b2ad1d11e6ee8",
+    "libopencv-highgui4.5_4.5.1+dfsg-5_amd64.deb": "2f0b59baa96ecc9368ca729016d876d5b7d377b511caa021fdb27e00df47b29c",
+    "libopencv-imgcodecs-dev_4.5.1+dfsg-5_amd64.deb": "a276492fb4e20eaab343bf84c70bd1e5bfbefc7e47fcdedcdbe6718892715dac",
+    "libopencv-imgcodecs4.5_4.5.1+dfsg-5_amd64.deb": "b5bde49837bdb1faca8764cf679e45807eed4126e65d92a5391c2d376359c6f3",
+    "libopencv-imgproc-dev_4.5.1+dfsg-5_amd64.deb": "9e2f780fa3d9b6fef898a19e82fbfdafe462286d2e6f698cbd66c7545d5ede87",
+    "libopencv-imgproc4.5_4.5.1+dfsg-5_amd64.deb": "58c93a50b180f8b8935d128438434a0e9407228e6181c4e7312402a486f0ba0a",
+    "libopencv-ml-dev_4.5.1+dfsg-5_amd64.deb": "413b744bfd48e7b945c36494e5aebdd81dcf2b1bea1ef94d918b8a308acb2c40",
+    "libopencv-ml4.5_4.5.1+dfsg-5_amd64.deb": "752861a15059f11a6c9c5d999e4ca00044e66c25bedb4ae7705af12700d885cc",
+    "libopencv-objdetect-dev_4.5.1+dfsg-5_amd64.deb": "a04d554cf783f54ef7cd86651db1411d1fc7c301b9e34b574393d4067b7656f9",
+    "libopencv-objdetect4.5_4.5.1+dfsg-5_amd64.deb": "cef019b21b06240137ef3c529b88c8c2bf0c0e2d4bd18afde1dfd622c8f60135",
+    "libopencv-photo-dev_4.5.1+dfsg-5_amd64.deb": "b565882f3b302d3183cf2d4e4282af963fd08dc9a4538f030b11cbfd23602e3e",
+    "libopencv-photo4.5_4.5.1+dfsg-5_amd64.deb": "b1f9ceed287fc233cac0bd5b219158c699d629a166a1153af25836ec2ed6d7c0",
+    "libopencv-shape-dev_4.5.1+dfsg-5_amd64.deb": "6c1d629d032dfb67d93da236433c1b9979aaf4ecada31d9a2ca38b78e2bf1de9",
+    "libopencv-shape4.5_4.5.1+dfsg-5_amd64.deb": "09ecbf7eaede648828313fb91d21621da2500a45ca9d4a1123be0e9137a317cf",
+    "libopencv-stitching-dev_4.5.1+dfsg-5_amd64.deb": "8524640ba6c94451b0ae20ff566272696c7da5ee150b779ea1002195d7fa77e7",
+    "libopencv-stitching4.5_4.5.1+dfsg-5_amd64.deb": "14134ea9c6edeb648f4aeca3b7920bfa0915b698554bbf227298ed2ee114c704",
+    "libopencv-superres-dev_4.5.1+dfsg-5_amd64.deb": "f7c830ad372c4df8ea546240a9dcb699e41e6e8555f97abbd705e8e46c01a255",
+    "libopencv-superres4.5_4.5.1+dfsg-5_amd64.deb": "cbe4d6331ee43427af5b3c6e9a9d34277cafae7f83759a7b073c88c0728ec2b3",
+    "libopencv-video-dev_4.5.1+dfsg-5_amd64.deb": "f0ec790005a4fa5bcb973b1640f37db373b39e07da2c041fa8a5953ce9175101",
+    "libopencv-video4.5_4.5.1+dfsg-5_amd64.deb": "dc83934e861d0feb4ee3b0d8a0ba058460eb56a80cc6ecb8a99e4bb2eb90cfb1",
+    "libopencv-videoio-dev_4.5.1+dfsg-5_amd64.deb": "4bd9fed0835f2c39f237242ceb48947339310bf78ef148df7330dee01d1fb6af",
+    "libopencv-videoio4.5_4.5.1+dfsg-5_amd64.deb": "2b0124d162ad10202dcbe7d9b714aeb7b9d47b04c434b14b38de44000d86f2f3",
+    "libopencv-videostab-dev_4.5.1+dfsg-5_amd64.deb": "90bd803824091f6d4843288fd057976e66c6d4faffc4ce96f3862995bf882822",
+    "libopencv-videostab4.5_4.5.1+dfsg-5_amd64.deb": "0e81fcbe8e786f17d242803b38f0e23c88ef20ab54b9e376661a86c71c557097",
+    "libopencv-viz-dev_4.5.1+dfsg-5_amd64.deb": "065a1b6646bd330a0eb3b3e58be5be205f1e046bc1f24c846d053c5e889e3beb",
+    "libopencv-viz4.5_4.5.1+dfsg-5_amd64.deb": "acc4812feb90115babee514ff417b9eca0258672163035c3b76e8c51b06ebed2",
+    "libopenexr-dev_2.5.4-2_amd64.deb": "bd730c004fb4c8433f88868e18fb2993e2bf359e410d3baff06de013ca725163",
+    "libopenexr25_2.5.4-2_amd64.deb": "ec97b36c66a060b987d75cb26f09e23cb5e4135e9d1be188f8f09a5d60b87902",
+    "libopengl0_1.3.2-1_amd64.deb": "4327a9f20b88e7bcb07af3b196121096877331b61eeed64467854eb0b525fc43",
+    "libopenh264-6_2.2.0+dfsg-2~bpo11+1_amd64.deb": "1bc69644a6cf305f1b9b447068983fec8200ba4bded28ed323c22edbb7fd0849",
+    "libopenjp2-7_2.4.0-3_amd64.deb": "f99e76456459aa19ac5f610096c7054994130597931abf660b82436c477ff03e",
+    "libopenmpt0_0.4.11-1_amd64.deb": "caa0c618ace54c14980b14d9dc8b5600313ba985e465a64acc59fd1ff5236901",
+    "libopenni2-0_2.2.0.33+dfsg-15_amd64.deb": "2875424fd7510c8cb5eae8dd5f4435b2dcdaef631fbd03973f71fa56fccba959",
+    "libopus0_1.3.1-0.1_amd64.deb": "f8249b9e88e01a2f8945ff3082d488b0b9470b25a1976ab409ed9aff118f9b6c",
+    "liborc-0.4-0_0.4.32-1_amd64.deb": "b1c7560723b12e498958a2af81d6df7f06c7b20d46ac191c2c4330cb6ce5483f",
+    "liborc-0.4-dev-bin_0.4.32-1_amd64.deb": "2069fdc8eb5b3e856695ef40f7d3cd402f4e00841735127f4390e9a3f58dd4d4",
+    "liborc-0.4-dev_0.4.32-1_amd64.deb": "75051ceec695ca956e2f6feecdf5d0df22db9f9390edce118516fbf8e077f612",
+    "libp11-kit0_0.23.22-1_amd64.deb": "bfef5f31ee1c730e56e16bb62cc5ff8372185106c75bf1ed1756c96703019457",
+    "libpango-1.0-0_1.46.2-3_amd64.deb": "cfb3079a7397cc7d50eabe28ea70ce15ba371c84efafd8f8529ee047e667f523",
+    "libpangocairo-1.0-0_1.46.2-3_amd64.deb": "f0489372e4bcb153d750934eb3cddd9104bc3a46d564aa10bef320ba89681d37",
+    "libpangoft2-1.0-0_1.46.2-3_amd64.deb": "78067d7222459902e22da6b4c1ab8ee84940752d25a5f3dea1a43f846a8562e3",
+    "libpciaccess0_0.16-1_amd64.deb": "f581ced157bd475477337860e7e7fcabeeb091444bc5a189c5c97adc8fcabda5",
+    "libpcre16-3_8.39-13_amd64.deb": "04ef146b0119a8a5ab1df09d990bd61a45bf99d2989aa248ebc7f72dbb99544e",
+    "libpcre2-16-0_10.36-2_amd64.deb": "720aa56730b7916680ce2859dbdaa722aa519859b0697d78b34e5c57ee6293c2",
+    "libpcre2-32-0_10.36-2_amd64.deb": "89558554df9e374de506d8372341e1a45a0d6ea8413dc2e49d5d357e571555ee",
+    "libpcre2-dev_10.36-2_amd64.deb": "75de539e873d7c58805ab38a4e17a7fb434abde8beadbe6fe4b8e477e84d68e5",
+    "libpcre2-posix2_10.36-2_amd64.deb": "179664cb063e1761fc8ebe04f8a02f17be22b79b1bdcf66404c3ee35b3884d09",
+    "libpcre3-dev_8.39-13_amd64.deb": "e588a2bd07e2770ad2fa9e3b02e359d3ff3c6f0c17a809365d3e97da7b0e64e0",
+    "libpcre32-3_8.39-13_amd64.deb": "961135f3ff2d00c2e46640b9730d9ddef80ae9d9037e2ec882ee8f6ce5dd48c9",
+    "libpcre3_8.39-13_amd64.deb": "48efcf2348967c211cd9408539edf7ec3fa9d800b33041f6511ccaecc1ffa9d0",
+    "libpcrecpp0v5_8.39-13_amd64.deb": "79e15b8d31f8561ad1c19f8c280d0a9fe280f7872701ef53c9bdfce6b3015a18",
+    "libpgm-5.3-0_5.3.128~dfsg-2_amd64.deb": "3f124acd98fb6d9d78dff583061736bcb738d102f3bd1e0afca4c0f0435534af",
+    "libpixman-1-0_0.40.0-1_amd64.deb": "55236a7d4b9db107eb480ac56b3aa786572ea577ba34323baf46aceb7ba6d012",
+    "libpng-dev_1.6.37-3_amd64.deb": "7be93d99bdab4fd3e230f67ad17739fdfa2bb1fb94ddd84f670e442ffbcabf39",
+    "libpng16-16_1.6.37-3_amd64.deb": "7d5336af395d1f658d0e66d74d0e1f4c632028750e7e04314d1a650e0317f3d6",
+    "libpoppler102_20.09.0-3.1_amd64.deb": "23918f0727b651b1b9346951f2e703a6c6ee69277def309bf0a9f0fb30c5ec1e",
+    "libpq5_13.5-0+deb11u1_amd64.deb": "0bfa1dc24e1275963961efdcc6d2ff4d2eec390d7acd5a6aee3162569ae1886c",
+    "libproj19_7.2.1-1_amd64.deb": "34b3b285f42d89e94e6315ae572ee9bdcb23278538d73b5c5f13526a8da77eae",
+    "libprotobuf23_3.12.4-1_amd64.deb": "c0eddff6bdee79086a2ffa74ed5949e22ff383757520433e70cadb7fcf34e5a5",
+    "libproxy1v5_0.4.17-1_amd64.deb": "b21c1524b972dd72387ecb8b12c0a860738ce0832ed18fe7ffb9da6adc9b9e41",
+    "libpsl-dev_0.21.0-1.2_amd64.deb": "5244ef677e55f85b6ef84ad152f3d2acb29899a98639005aa227290e973db4d0",
+    "libpsl5_0.21.0-1.2_amd64.deb": "d716f5b4346ec85bb728f4530abeb1da4a79f696c72d7f774c59ba127c202fa7",
     "libpthread-stubs0-dev_0.4-1_amd64.deb": "54632f160e1e8a43656a87195a547391038c4ca0f53291b849cd4457ba5dfde9",
-    "libpython2.7-minimal_2.7.16-2+deb10u1_amd64.deb": "8a54dfa6c30ced68dafc159d88adb8c096697a993023bb5e31f2dfd93e386474",
-    "libpython2.7-stdlib_2.7.16-2+deb10u1_amd64.deb": "96c9e7ad71da07f47b7356b416b7f5d6d9e8eda1404b2c8a8ba8edda3799177b",
-    "libpython2.7_2.7.16-2+deb10u1_amd64.deb": "e5dcd5ff5be854e9c7645f1a349701e809078051ef88dd119dc55d07c2e1f7bb",
-    "libpython3-stdlib_3.7.3-1_amd64.deb": "4f8883d378e698aa89b7bd4b68ce8e7cca01c961d3df87fafe4c079bb4668f5b",
-    "libpython3.7-minimal_3.7.3-2+deb10u1_amd64.deb": "b3d45767c2f6ff022bc76f9a1bedd445f7e90584f844e459604c856d91193fdd",
-    "libpython3.7-stdlib_3.7.3-2+deb10u1_amd64.deb": "993d6e8bad12cea70257c96f2f76f1c4a5afe7506992971dd9b6924fcb924657",
-    "libqhull7_2015.2-4_amd64.deb": "1bae4f773f67a27a9de59eb387f8dc425d62a46baf2e1ca86f3b0e50ca88e1f2",
-    "libquadmath0_8.3.0-6_amd64.deb": "766684a231a740b434468e1c7146353fcddff7b8e14644a82672299459c53c34",
-    "libraw1394-11_2.1.2-1+b1_amd64.deb": "83542d8989a81b222cada2b47eaeee11beebf35e8031dcb55ae741d00a076139",
-    "libraw1394-dev_2.1.2-1+b1_amd64.deb": "7b19568a113a488246913f1072f41ce7532d942fd211748c96296985a018059c",
-    "librdmacm1_22.1-1_amd64.deb": "59851755a31fd3f8731451923f4edddfacc161f929b1966df68530e3e662b9e5",
-    "libreadline7_7.0-5_amd64.deb": "01e99d68427722e64c603d45f00063c303b02afb53d85c8d1476deca70db64c6",
-    "librest-0.7-0_0.8.1-1_amd64.deb": "17d25479dd8fb0bfc7fd92ca92d7c063e9d0a22f43cb90e2de243b89111cde93",
-    "librsvg2-2_2.44.10-2.1_amd64.deb": "181188485d646e0ac29e79df67d8fa3ca7a984bb65024b06b36e917b4e282e21",
-    "librsvg2-common_2.44.10-2.1_amd64.deb": "c873d99436da50dfcc23104d827bd73e5063d9ee5742f39ffeb44ba1145af5e1",
-    "librtmp1_2.4+20151223.gitfa8646d.1-2_amd64.deb": "506fc9e1fc66f34e6f3f79555619cc12a15388c3bdd5387c1e89d78b19d1b5dc",
-    "libsamplerate0_0.1.9-2_amd64.deb": "8a3cf8a4405de7f5e8474c8f5e298dfd817a0217f113f4292dd7a7c378be2f60",
-    "libsasl2-2_2.1.27+dfsg-1+deb10u1_amd64.deb": "4a3fb6e0953789f3de455ad7c921294978d734e6395bc45bd6039dcd9634d263",
-    "libsasl2-modules-db_2.1.27+dfsg-1+deb10u1_amd64.deb": "c99437674b33964f44eb54b1a4d8cb5bbca0293989cd3d426bcb54e9f54d88db",
-    "libselinux1_2.8-1+b1_amd64.deb": "05238a8c13c32418511a965e7b756ab031c140ef154ca0b3b2a1bb7a14e2faab",
-    "libselinux1-dev_2.8-1+b1_amd64.deb": "d98880fbaa0fa1035d684ec8912e8f0f9c2d1d738bf03eb0ca052be548bc8297",
-    "libsemanage-common_2.8-2_all.deb": "fa3c50e11afa9250f823218898084bdefea73c7cd1995ef5ed5e7c12e7b46331",
-    "libsemanage1_2.8-2_amd64.deb": "ebc5346a40336fb481865e48a2a5356b5124fc868269dc2c1fbab2bdc2ac495e",
-    "libsensors-config_3.5.0-3_all.deb": "a064dbafa1590562e979852aca9802fc10ecfb6fda5403369c903fb38fa9802a",
-    "libsensors5_3.5.0-3_amd64.deb": "363ea208bfe6bf3dd1f66914eae5a15373fef0d72f84df013eb6d60633866c50",
-    "libsepol1-dev_2.8-1_amd64.deb": "fff0388005333eae45f2b27b9daf8d52b4392aa27becdabc304e70925b9fbac8",
-    "libsepol1_2.8-1_amd64.deb": "5e4ebf890bab2422d3caff579006c02cc3b153e98a61b8c548a951e24c0693f2",
+    "libpulse0_14.2-2_amd64.deb": "f2d2ed93c03cff7cf081d401d855d67e1f73b65dec02687d309e0d72e7d1159d",
+    "libqhull8.0_2020.2-3_amd64.deb": "d30aa8231afdf7997f57a7c28be25868f1f60ea01c7bdb1990e030514a74b9a5",
+    "libqrencode4_4.1.1-1_amd64.deb": "80b901703c5347798e2d87f1275aed1e5375ebc3618ec7fe43b34f7d9490ac64",
+    "libquadmath0_10.2.1-6_amd64.deb": "a9a5e1f53b7e27a3f2b8388929bb622d3c6c35a4e42ac166697444e5ed662fd5",
+    "librabbitmq4_0.10.0-1_amd64.deb": "2c91f91ead5534cda268350a816a64e656fd6fb9d2b658cb3c23ae0424cffa2f",
+    "libraw1394-11_2.1.2-2_amd64.deb": "d8cb92f085d3b32ca23e31b2bf45f66d678f585fef8f8b85510bd41b8ff966ee",
+    "libraw1394-dev_2.1.2-2_amd64.deb": "6cbcde30fa362e8a9e98749e8231c60d3ec561f21e7670d13989073e2e628c98",
+    "libreadline8_8.1-1_amd64.deb": "162ba9fdcde81b5502953ed4d84b24e8ad4e380bbd02990ab1a0e3edffca3c22",
+    "librest-0.7-0_0.8.1-1.1_amd64.deb": "5cd57a96145a362bf60428315ab3fc6c2f528ab38a06a905da2568575c23bdc8",
+    "librsvg2-2_2.50.3+dfsg-1_amd64.deb": "c5f6cdb66683d9b8cd23f0e02e6adb29d43bdca301872842fa98d44e23fa1091",
+    "librtmp1_2.4+20151223.gitfa8646d.1-2+b2_amd64.deb": "e1f69020dc2c466e421ec6a58406b643be8b5c382abf0f8989011c1d3df91c87",
+    "librttopo1_1.1.0-2_amd64.deb": "ce14f3a8a4451398302b2df9fe2fa77df8c4f8df8bee125a52cecccbfbd48960",
+    "libsamplerate0_0.2.1+ds0-1_amd64.deb": "be57259ee0a160557a9492ca001c6cfbd816af661409673ef431465a728bb746",
+    "libsasl2-2_2.1.27+dfsg-2.1+deb11u1_amd64.deb": "2e86ab7a3329aad4b7350a9b067fe8f80b680302f2f82d94f73f9bf075404460",
+    "libsasl2-modules-db_2.1.27+dfsg-2.1+deb11u1_amd64.deb": "122bf3de4ca0ec873bc35bdde1f21ec9d91ace4f5245c3b1240e077f866e1ae9",
+    "libsbc1_1.5-3_amd64.deb": "3ec64d259335cf5582c30fc6e00b492433184d7b4d46b1840578acebf5e005d3",
+    "libsdl2-2.0-0_2.0.14+dfsg2-3_amd64.deb": "42ad145ae733550489913fd68ccafbce85ca68571d7b36e562923c2d37b89cb0",
+    "libselinux1-dev_3.1-3_amd64.deb": "16b14d7e8ed88b9b07d1b52d84d04ab2fcdfcdc4b8cecc9dd34df06f3ce7d3fb",
+    "libsensors-config_3.6.0-7_all.deb": "4265811140a591d27c99d026b63707d8235d98c73d7543c66ab9ec73c28523fc",
+    "libsensors5_3.6.0-7_amd64.deb": "b9cb9a081ea3c9b68ef047d7e51f3b84bccde1a2467d5657df4c5d54775b187e",
+    "libsepol1-dev_3.1-1_amd64.deb": "1bec586de489db87c8746a6eeed27982915fc578c91e9e78ef39773ab824e023",
+    "libsepol1_3.1-1_amd64.deb": "b6057dc6806a6dfaef74b09d84d1f18716d7a6d2f1da30520cef555210c6af62",
+    "libserd-0-0_0.30.10-2_amd64.deb": "fb48a540070b8b044f78a787d8c65d8b85540cf8f165223e08d8554a8b9aba79",
     "libshine3_3.1.1-2_amd64.deb": "6b09f0d577f515feffc071048218a26cdde5346d6e2661f861009897db0204d2",
-    "libshout3_2.4.1-2_amd64.deb": "76cb50f044716523a7531c9a89457ed042f1b5ee3266f6eb3644990d0437c26f",
-    "libsidplay1v5_1.36.59-11_amd64.deb": "dd5fa21ffa1257f33637fe29d1b1a0efe64e15b6bb2dfd53985a4f584c96362a",
-    "libslang2_2.3.2-2_amd64.deb": "d94c51ea5cdf253019b67867bf4b0a5116ab224e97fd767614f0af31c63477bd",
-    "libsm6_1.2.3-1_amd64.deb": "22a420890489023346f30fecef14ea900a0788e7bf959ef826aabb83944fccfb",
-    "libsnappy1v5_1.1.7-1_amd64.deb": "e791ed82f816844219a27e3680ed50753a893a34f38f3e69ed08c4abc389cbf8",
-    "libsocket++1_1.12.13-10_amd64.deb": "6611c010f2eb12786f82b80ed7029ca48b2c3ed675d693ffa38e629d33a4e1e2",
-    "libsoup-gnome2.4-1_2.64.2-2_amd64.deb": "33c571659e0fe2ba55214d2c68b15d883215c6c0e08e6037173da92585f9a623",
-    "libsoup2.4-1_2.64.2-2_amd64.deb": "db9918e3937eb4f92068665a9b42ea33b0860da602fa5c2f0e80e5cb15a556c4",
-    "libsoxr0_0.1.2-3_amd64.deb": "e8af4d04065bcca876f0e2bb1824bb0ce710a2ec10a9b1a320e210bebbc3dba7",
-    "libspatialite7_4.3.0a-5+b2_amd64.deb": "f22d5a7da9fa1358737007e12da8cb073f1d8db5cf02b1213437eed707cef656",
-    "libspeex1_1.2~rc1.2-1+b2_amd64.deb": "228dfcfa7dd3fd85aa3bb60c21de45489e3ce3f2274a80cac3992797ef8e542e",
-    "libsqlite3-0_3.27.2-3_amd64.deb": "ff247b1c0527cc7322af8d47260268db079e94284ee12352b31be912d30ce2a1",
-    "libssh-gcrypt-4_0.8.7-1_amd64.deb": "b18787dbff57eba507ae9b282688d90208e818357a76130b6195eb3d68faefc9",
-    "libssh2-1_1.8.0-2.1_amd64.deb": "0226c5853f5e48d7e99796c2e6332591383e9c337ac588e1b689f537abd0a891",
-    "libssl1.1_1.1.1d-0+deb10u2_amd64.deb": "31c15130e0e4b2c907ef7cd92e50be23320a22c0c3b54e130b5258fe6bd8df2d",
-    "libstdc++6_8.3.0-6_amd64.deb": "5cc70625329655ff9382580971d4616db8aa39af958b7c995ee84598f142a4ee",
-    "libsuperlu5_5.2.1+dfsg1-4_amd64.deb": "475d366d3a322c10111785b3e6d6f519d35831490388d1eea11e430d6e2fa711",
-    "libswresample-dev_4.1.4-1~deb10u1_amd64.deb": "f3f1a10ba6f95b35d2c2c272cf66d51fc166bf589044f8cbf8376008b12cce38",
-    "libswresample3_4.1.4-1~deb10u1_amd64.deb": "41950f8346f92b2208fe013fec0b722448be6bc4d20d4f161a8aa3b13edd4a74",
-    "libswscale-dev_4.1.4-1~deb10u1_amd64.deb": "d445fcb352b8810f0c6f844a0bc2dab8e7ccdb14846677a35489951543c6b969",
-    "libswscale5_4.1.4-1~deb10u1_amd64.deb": "1f74aaa422e55fe2ac43633a9034e432d8c9ba986d53bea361ac82152c364ea3",
-    "libsystemd0_241-7~deb10u3_amd64.deb": "ff64489d01d4fdba32f55e251dcb5e5f5f26c4fe4f43f96c094fbda9323bafee",
-    "libsz2_1.0.2-1_amd64.deb": "1cfe425dbc24e2143549ba4f18e53f9b45e8645298c2d1388a649d7108ae3604",
-    "libtag1v5-vanilla_1.11.1+dfsg.1-0.3_amd64.deb": "2cf03256786f232323c882cc7853dcd5179c9306819feaf22b9079c1398e5181",
-    "libtag1v5_1.11.1+dfsg.1-0.3_amd64.deb": "4ed09f8e76d19e59e487e4784ce192e58b7ff4414d7b05233f0c3002718596e7",
-    "libtasn1-6_4.13-3_amd64.deb": "2771ea1ba49d30f033e67e708f71da9b031649c7c13d2ce04cb3ec913ac3b839",
-    "libtbb-dev_2018~U6-4_amd64.deb": "8c3236b7ee59e6a529a6a6be4a89622a034d13a841595f2ce63ee562531934e0",
-    "libtbb2_2018~U6-4_amd64.deb": "39df49a8f732da2088369326f2f0f53f99baa0c2d1ce9f3ceb8654ebb0bbc676",
-    "libtcl8.6_8.6.9+dfsg-2_amd64.deb": "7b5d095b83e13b9b571cfecde55834b770735e29ff23a52d45e9f4692d4c64a1",
-    "libtesseract4_4.0.0-2_amd64.deb": "8e96d37eceff951c9e89f328577cb177faf6813bbd76a8c4a7deede72f73a680",
-    "libthai-data_0.1.28-2_all.deb": "267d6b251f77c17fb1415ac0727675cb978c895cc1c77d7540e7133125614366",
-    "libthai0_0.1.28-2_amd64.deb": "40e7fbd1ed27185879836b43fb8a739c8991a6d589fef9fb2b3b63e188a537ae",
+    "libshout3_2.4.5-1+b1_amd64.deb": "c0e76f97bbd4a4145cbc77f2cea7de044ee8b8aa176c8a9d838cf6cbfec4d092",
+    "libsidplay1v5_1.36.60-1_amd64.deb": "e34cbbde2ee6eb6db75a58250f3ad4df2da14386357d47b95f14e6276327525a",
+    "libslang2_2.3.2-5_amd64.deb": "107ad70aba3dc4dab2bc0fe11c3dd7c2afe9549dd45f4da3f4cf9d360e171eba",
+    "libsnappy1v5_1.1.8-1_amd64.deb": "7e34c4e1e3b85c51ed302af50d30d6ef88889d87e310d50dde2ad31dbae3f606",
+    "libsndfile1_1.0.31-2_amd64.deb": "2d703696ec4673051f0f566417871482787749720773e3ac2d909b4a1b937e02",
+    "libsndio7.0_1.5.0-3_amd64.deb": "af3b9425fca1abad25be51774fec175e75f1b92f7a1909e9c27bbbf644c23550",
+    "libsocket++1_1.12.13-11_amd64.deb": "0acd83b0ceacca57aa15e8f95df9f4e591071a8408cdac77a69fddb8e956df60",
+    "libsodium23_1.0.18-1_amd64.deb": "f72e5b1e3a716154c284d98969bb698701daa30b02d755a78d10d460c582d48b",
+    "libsord-0-0_0.16.8-2_amd64.deb": "424f5ac84de7e071e85fd49b9b87c6672acd6eaa778ce26e4f3bf086d6a40dd6",
+    "libsoundtouch1_2.2+ds1-2_amd64.deb": "4387b20aa2a3b514d0e2a0d7465fb4599b1c2455b1637ab5beec17528e152906",
+    "libsoup-gnome2.4-1_2.72.0-2_amd64.deb": "7fdc774b567e3a5e0881aa01fcfcac637fdeeb8ea6233b710571e1f5b3a994b6",
+    "libsoup2.4-1_2.72.0-2_amd64.deb": "32dad5305be0faa619df36688a20d187ba915f02e9e184cc5c3c6e3d98259e9c",
+    "libsoup2.4-dev_2.72.0-2_amd64.deb": "6d091b91beb2290c1d9a5272aaf006c96e08bee1b29dd96392da8d37fd4af32b",
+    "libsoxr0_0.1.3-4_amd64.deb": "73a9f1a290da86562333430517c3f44282f17fcbeefcc2ba7f8abbc2e686f6f3",
+    "libspandsp2_0.0.6+dfsg-2_amd64.deb": "67a140af59ca7f3d75d2a687602bb9e9446cd482ff6b8de9dfcedbe50b1aa119",
+    "libspatialite7_5.0.1-2_amd64.deb": "d7ad246c34ead53e167d6c6eb831b6f4ffe3764c5c43bc629d3390d59f924f03",
+    "libspeex1_1.2~rc1.2-1.1_amd64.deb": "1e5eafc996486d89891897ac3bf0b947dacb5c211514222439b74bcaab6b95ea",
+    "libsqlite3-0_3.34.1-3_amd64.deb": "a0b8d3acf4a0483048637637d269be93af48d5c16f6f139f53edd13384ad4686",
+    "libsqlite3-dev_3.34.1-3_amd64.deb": "1880f26535eb1f7325017fb16bba3f1b9e54d74f3980fca0ec2ddda15acb1915",
+    "libsratom-0-0_0.6.8-1_amd64.deb": "1b4bf67b2c0f2f0df4e1c63f10fe480e069c099ee9479036a4e10bca87911ea2",
+    "libsrt1.4-gnutls_1.4.2-1.3_amd64.deb": "e146115bfe15d58ff00f376b2a8252f2fff8d6dcad060b08fb6346a2653ad800",
+    "libsrtp2-1_2.3.0-5_amd64.deb": "edeb4792a2030b810c116a338aa3b1127b07626b26ca6b1fcd3326273aee7f1e",
+    "libssh-gcrypt-4_0.9.5-1+deb11u1_amd64.deb": "47f4011e5220f319cf5c0fde69d7b466afac1be7c8030dc10fad9b147af6973f",
+    "libssh2-1_1.9.0-2_amd64.deb": "f730fe45716a206003597819ececeeffe0fff754bdbbd0105425a177aa20a2de",
+    "libstdc++6_10.2.1-6_amd64.deb": "5c155c58935870bf3b4bfe769116841c0d286a74f59eccfd5645693ac23f06b1",
+    "libsuperlu5_5.2.2+dfsg1-2_amd64.deb": "9f91a68dc8221cd67b7af765b44fb52401a0dc7609f5c4b926afb6362e475366",
+    "libswresample-dev_4.3.3-0+deb11u1_amd64.deb": "089954a478d194917bf648fc685c5ece35846f8c85eea14ead99a82bc1f538da",
+    "libswresample3_4.3.3-0+deb11u1_amd64.deb": "d687ba1d94fb4eb89e52f92761785d4bfe165e1a9e2d62b891e0644df3b8d73c",
+    "libswscale-dev_4.3.3-0+deb11u1_amd64.deb": "584607defe497fe6f6874419f430028d54392cd23a1ec68853dabb9d7b98e734",
+    "libswscale5_4.3.3-0+deb11u1_amd64.deb": "47abd5f1dfb0e633f2d6f343ad4dfc881f20c9548041e9878f701437a6349156",
+    "libsystemd0_247.3-7_amd64.deb": "5d7d8ee6a4e2f1d48fab1e63a8c6b515a9189936ea162c7a4b0bd5cd09cfd157",
+    "libsz2_1.0.4-1_amd64.deb": "4e833c185bf02d75d013f888677d65afa25c5b84769736860d53f9dbb0f349a2",
+    "libtag1v5-vanilla_1.11.1+dfsg.1-3_amd64.deb": "b53b12cc59f86e4b3ae4bdce2b1620858ce9c450769b7d303df6ef9c5d971570",
+    "libtag1v5_1.11.1+dfsg.1-3_amd64.deb": "4abe55761b4fce387ae27b9b3ebcb43474f85c85f438b08a953b1b84799edd28",
+    "libtasn1-6_4.16.0-2_amd64.deb": "fd7a200100298c2556e67bdc1a5faf5cf21c3136fa47f381d7e9769233ee88a1",
+    "libtbb-dev_2020.3-1_amd64.deb": "8c3f7e2406807c93c197f19d18f5ea92d1a11a7f24c523ebfd5a0a6f3273440f",
+    "libtbb2_2020.3-1_amd64.deb": "87ac7778820cbd7a2c7485f7fccd2ac4437b39cbb390e49b3aeec38a826f5af9",
+    "libtcl8.6_8.6.11+dfsg-1_amd64.deb": "785df3d81010a67ded4a2c216c7b99657c6ab3d1ba7369119894abc851e5bb0c",
+    "libtesseract4_4.1.1-2.1_amd64.deb": "7f2b8ccac9446e4cb2bff265e1b36e513a0978b62fb7687de0e61da14135b6e4",
+    "libthai-data_0.1.28-3_all.deb": "64750cb822e54627a25b5a00cde06e233b5dea28571690215f672af97937f01b",
+    "libthai0_0.1.28-3_amd64.deb": "446e2b6e8e8a0f5f6c0de0a40c2aa4e1c2cf806efc450c37f5358c7ff1092d6a",
     "libtheora0_1.1.1+dfsg.1-15_amd64.deb": "ca02e9d81aac51287601f7886db67f746fff83a8b744afc4647c34a09881aae2",
-    "libtiff-dev_4.1.0+git191117-2~deb10u1_amd64.deb": "0ca4c0388ca816ab348050e10dc7c82f53ec4c39a55a0e79702e8b0ef46be174",
-    "libtiff5_4.1.0+git191117-2~deb10u1_amd64.deb": "3fe1a515b8be7987aecc8bfde57066e6f008289e86493bbd676d1ebd8e40cd7e",
-    "libtiffxx5_4.1.0+git191117-2~deb10u1_amd64.deb": "e8172e3beb684c171c8705047418570903502fee90a3e965f2ddfe66c65611b9",
-    "libtinfo6_6.1+20181013-2+deb10u2_amd64.deb": "7f39c7a7b02c3373a427aa276830a6e1e0c4cc003371f34e2e50e9992aa70e1a",
-    "libtk8.6_8.6.9-2_amd64.deb": "a250aba06a5fc9c90622b6e1c3560ff351f945ed7234f61267ec3688370d1770",
-    "libtwolame0_0.3.13-4_amd64.deb": "b22893a3a1fa5a98b75405efb27ca07f96454d9ac16cccc91160ea67a0c18102",
-    "libudev1_241-7~deb10u3_amd64.deb": "77f123122993ad99dbbdb352822a50abec400bd8a353e84f0647b6a355c31893",
-    "libunistring2_0.9.10-1_amd64.deb": "bc3961271c9f78e7ef93dec3bf7c1047f2cde73dfc3e2b0c475b6115b76780f8",
-    "liburiparser1_0.9.1-1_amd64.deb": "005564c21755fcaae2e1c10c277b43c94eec546c52797eb6d053977cebea2d8b",
-    "libusb-1.0-0_1.0.22-2_amd64.deb": "37be9e682f0fd7533b7bb9d91af802a5070ad68eb9434036af5bc2815efb2615",
-    "libuuid1_2.33.1-0.1_amd64.deb": "90b90bef4593d4f347fb1e74a63c5609daa86d4c5003b14e85f58628d6c118b2",
-    "libv4l-0_1.16.3-3_amd64.deb": "6864b565634e51d2f1cc51a95f42a79ff51c83915aa556a827b2b71227dbdc08",
-    "libv4lconvert0_1.16.3-3_amd64.deb": "52c3ad5548fb2a0b16b36a64b37ca86fd76cb49e76369281e59923be4038c596",
-    "libva-drm2_2.4.0-1_amd64.deb": "6790e8d48840780f93a9f4566f99f53ae6bf95597fddfe183526885a7b49911f",
-    "libva-x11-2_2.4.0-1_amd64.deb": "d4b632c6f216759ccd4052ef7ee95bc2f32d6aea21bbdb8cfe370f189193c32f",
-    "libva2_2.4.0-1_amd64.deb": "40a89587dea750033d0c03dbc6580c54872400a3e8254d8f0bd1ab93e3d5379d",
-    "libvdpau1_1.1.1-10_amd64.deb": "405f005d362c260bd044dbe2780212bd94e6a9225220fe29126edcf3ff5a345d",
-    "libvisual-0.4-0_0.4.0-15_amd64.deb": "e8bbfaf5d5172ca84dfb8002f51d59f35e59ca98a3e3aad28744f69bad305995",
-    "libvorbis0a_1.3.6-2_amd64.deb": "ca25986889a378ffe90c977739f8184858cc9c3c0fd287c2f29e19369855c6f3",
-    "libvorbisenc2_1.3.6-2_amd64.deb": "04ffe79e724c230778bf8a9875a455bd24d8a15c3b453b2a1b5125120c4a5044",
-    "libvorbisfile3_1.3.6-2_amd64.deb": "7bb4e70414c9f8a9cfdc86a64eb8659e889fa74e1f54a8cfc050ec5b6c9faace",
-    "libvpx5_1.7.0-3+deb10u1_amd64.deb": "72d8466a4113dd97d2ca96f778cad6c72936914165edafbed7d08ad3a1679fec",
-    "libvtk6.3_6.3.0+dfsg2-2+b5_amd64.deb": "d455661b50ecfcbd5305dc03f249b24032dc3e6b5d86f429a80835bea7adc4b1",
-    "libwavpack1_5.1.0-6_amd64.deb": "5007546fc6cefb212c894dd6f463aaf9227c0b82f9442ecb0e257adeb9d3a0c8",
-    "libwayland-bin_1.16.0-1_amd64.deb": "a394cff3d6b7b4fd4e7c401ff2b56beb110e4aa3f2e1566a339da2d987de5e11",
-    "libwayland-client0_1.16.0-1_amd64.deb": "826fdd1a6a5ffa01415f138e238da858aae22ac4f4835cedfecab76dd0dcb01b",
-    "libwayland-cursor0_1.16.0-1_amd64.deb": "eee990ea0ad68ac409986ebf92106b8deada54cc2cfd19293177f5f938c35690",
-    "libwayland-dev_1.16.0-1_amd64.deb": "7d978fe21ea070b9f1a80327292d90a8644f50da27284c245e54c0b7f5602999",
-    "libwayland-egl1_1.16.0-1_amd64.deb": "a021e9aa9a92270fa259211a0ca69b5e8428f32c6e800a4a93f0766b0a48a5c6",
-    "libwayland-server0_1.16.0-1_amd64.deb": "93c7bb9dfd107f1e7d2b3e0a9af6efc653d75cc5e58f653cfd14afc12d125655",
-    "libwebp6_0.6.1-2_amd64.deb": "7d9cb5e08149327731e84380e454a56f148c517ec2ecad30900c6837d0b1b76a",
-    "libwebpmux3_0.6.1-2_amd64.deb": "89d70c819420ddc636994b18ec4ad35b8edea49567b59304a4bc88701168cd9f",
-    "libx11-6_1.6.7-1_amd64.deb": "9e6592d7fc9ef52f3c88c68ce3788341af6c8a90868928ab8416f7d35e28aed6",
-    "libx11-data_1.6.7-1_all.deb": "eb9e373fa57bf61fe3a3ecb2e869deb639aab5c7a53c90144ce903da255f7431",
-    "libx11-dev_1.6.7-1_amd64.deb": "9d13c5ee3119679d14aa809e637a2d868c72003345cf7d25fc04557a58ec5f27",
-    "libx11-xcb-dev_1.6.7-1_amd64.deb": "52116465eb2b886f3df9ea86659b09204114e39104e84ab1c538cc42c9cc1a20",
-    "libx11-xcb1_1.6.7-1_amd64.deb": "576a174412174def47014ddd71443cb65588ba243196e0001b3186273361d857",
-    "libx264-155_0.155.2917+git0a84d98-2_amd64.deb": "37c8b5be1ddaddf6abc92d284372474584c5e1ceb2f2ec12a4296a7c55ea5b60",
-    "libx265-165_2.9-4_amd64.deb": "3c90c5a6b2a69a3de321c3781ebf6640ecd693651bd99526c5f18664fbb16f63",
-    "libxau-dev_1.0.8-1+b2_amd64.deb": "5a994d70f36e0cafe99b38f681e584971db6cc932df0380ebca0fec0c32a4295",
-    "libxau6_1.0.8-1+b2_amd64.deb": "a7857b726c3e0d16cda2fbb9020d42e024a3160d54ef858f58578612276683e8",
-    "libxcb-dri2-0-dev_1.13.1-2_amd64.deb": "e58f8fb9e7b58f17aba45167ea9dd019ee6dd75413f6327f716a988fb7a78a7f",
-    "libxcb-dri2-0_1.13.1-2_amd64.deb": "1604da91e88a88395add6588d8b6227098acc2680ee1f234697219036f4d22b1",
-    "libxcb-dri3-0_1.13.1-2_amd64.deb": "931d9c7be021a45ae69fb99f72fde393402f3d38355ecbcf8c1742e19749a0df",
-    "libxcb-dri3-dev_1.13.1-2_amd64.deb": "7919943a87bcae91e99dd79da0cd85265b9f291cfdd48e3e9f8dd56b24a9c578",
-    "libxcb-glx0-dev_1.13.1-2_amd64.deb": "cff2a773888d9ea84358210bd4a12223cc9a1f3d05b8357269309d8194a2fa83",
-    "libxcb-glx0_1.13.1-2_amd64.deb": "ba58285fe011506fed6e2401e5623d924542864362eb68d5e724555af5195d11",
-    "libxcb-present-dev_1.13.1-2_amd64.deb": "b778a671ef3e89d44009fc9cd10d234c6d2c9b0312ef48351bd6cd3e27261773",
-    "libxcb-present0_1.13.1-2_amd64.deb": "fb531c51237c2371bc9a9924f3e70b15fb004181444473bc932b7ad9263500cb",
-    "libxcb-randr0-dev_1.13.1-2_amd64.deb": "b428af3473515445d598ed1b49159039bcfcaeca7bd097f8366d2ba7294aae0a",
-    "libxcb-randr0_1.13.1-2_amd64.deb": "7d5f213e48f27bd1c4b3a4b5e46f4519cf0d2d33403c19dbf3891fbb2a599fc4",
-    "libxcb-render0-dev_1.13.1-2_amd64.deb": "64249d7ac1bc82b202906433fdba7c8b18130f51c1561bdfc7c1886c32d74e5e",
-    "libxcb-render0_1.13.1-2_amd64.deb": "7bd78eb3d27de76d43185d68914e938d60f233737f7a05586888072695cab6fb",
-    "libxcb-shape0-dev_1.13.1-2_amd64.deb": "aa451e4d713bbc37f327b6f6b9767372dd298e6c3fc4e6287349c5c45836fa40",
-    "libxcb-shape0_1.13.1-2_amd64.deb": "971be06832051730a59ef0db4ed49f49efa0539d36f5acf5d1ee0a6e67a1e3bf",
-    "libxcb-shm0_1.13.1-2_amd64.deb": "a7a9927c9b656c253fe6f61497b94aa7332e2270cc30ca67c2925a3ecb61d742",
-    "libxcb-sync-dev_1.13.1-2_amd64.deb": "32680293f03a28af11271aa4b8a39de047fdad329f5125dd53054da360fb5382",
-    "libxcb-sync1_1.13.1-2_amd64.deb": "991807437dc07687ae2622f0e6ee8aff87695e13003921f469e5b6a495f55e3b",
-    "libxcb-xfixes0-dev_1.13.1-2_amd64.deb": "a0f5bd931af6941688a024b74cf0d29122a09a074e65599b4e13bc87fbd24d24",
-    "libxcb-xfixes0_1.13.1-2_amd64.deb": "ade907976731e9c80dd87149647eb94197ae5a6d534712f1c18c58192b6a8be4",
-    "libxcb1-dev_1.13.1-2_amd64.deb": "237e0336b66c96e651b04221f03fe021c3052438bf9bedb85440e7cb48dfa890",
-    "libxcb1_1.13.1-2_amd64.deb": "87d9ed9340dc3cb6d7ce024d2e046a659d91356863083715d2c428a32e908833",
-    "libxcomposite1_0.4.4-2_amd64.deb": "043c878356954f4521c401b160d554809115c472ca384d9f793c1c7542316eb9",
-    "libxcursor1_1.1.15-2_amd64.deb": "5c5c3c5020b3e963afcf45af21ad8c0c14375ae35f6c649a05a22790503bf24c",
-    "libxdamage-dev_1.1.4-3+b3_amd64.deb": "4fbfdf647a2a082112ad9a0b84a0780fac2d0fbfabf1b7cb2cc6325fc096ac4a",
-    "libxdamage1_1.1.4-3+b3_amd64.deb": "e9539838d47cb10b4273c320f8e885ef85df7bd3a95f0ea9bcbc144db82c03ae",
+    "libtiff-dev_4.2.0-1+deb11u1_amd64.deb": "9936e0503ad418bab17e59dcf67a39c752a3d489b2f3d228b59e07fdcd4860e1",
+    "libtiff5_4.2.0-1+deb11u1_amd64.deb": "b22d25e14421a36c4c3b721c04c6312d79ccd91c9a0e2291f58e36b8d4a07fbb",
+    "libtiffxx5_4.2.0-1+deb11u1_amd64.deb": "bf54e53c47a81c51068b03fee8a53c6bd53a6c115218c34904fe69c4f725c9e0",
+    "libtinfo6_6.2+20201114-2_amd64.deb": "aeaf942c71ecc0ed081efdead1a1de304dcd513a9fc06791f26992e76986597b",
+    "libtk8.6_8.6.11-2_amd64.deb": "20d70721a5d539266a8736800378398d088419b986b5313ca811203284690f12",
+    "libtwolame0_0.4.0-2_amd64.deb": "279802de79d682a671cdb11295abb5cd2d21da5bee6ceefa44324c70a29365b1",
+    "libudev1_247.3-7_amd64.deb": "379ba45ef8b884f686ac0af435fb307137a86e39ee816ae2516f14ff60332488",
+    "libudfread0_1.1.1-1_amd64.deb": "0bd73adf50441a403de1301ce8b2335a315c5dbc6b84893e5d8a79f71ffc49a1",
+    "libunistring2_0.9.10-4_amd64.deb": "654433ad02d3a8b05c1683c6c29a224500bf343039c34dcec4e5e9515345e3d4",
+    "libunwind-dev_1.3.2-2_amd64.deb": "44cdc2b873368b465905cdb06aecf00d5f6d4c4d363718535171f2232110d364",
+    "libunwind8_1.3.2-2_amd64.deb": "a8cc1181a479375aeb603cfe748cc19dc3a700a47ffdcb09fa025fe02b0c73bf",
+    "liburiparser1_0.9.4+dfsg-1+deb11u1_amd64.deb": "668403c9537b40280902de700099cc57938edd75a531ed2ac0d59d3c11325622",
+    "libusb-1.0-0_1.0.24-3_amd64.deb": "946bf6ecad3cec1275fb5a5bedd5cb50676e55d5f5cfb6e28d756442d4601c41",
+    "libuuid1_2.36.1-8+deb11u1_amd64.deb": "31250af4dd3b7d1519326a9a6764d1466a93d8f498cf6545058761ebc38b2823",
+    "libv4l-0_1.20.0-2_amd64.deb": "58c600f7b22c46e3e845127a9654fd74a47f11e67e53513c018dfedd07995c19",
+    "libv4lconvert0_1.20.0-2_amd64.deb": "691106607bf5e52ac8cb54b74cb52e39a4f19a1a909c866bb661cd01f74cdff3",
+    "libva-drm2_2.10.0-1_amd64.deb": "b705c4186947d6c90682d5fcf777ba267d93058b1b50b541c29f8421f14782f5",
+    "libva-x11-2_2.10.0-1_amd64.deb": "a51c8da767b49d78cd037b9da72eb26aff1f5a9cc2bc91b5eca4931d8d5649b0",
+    "libva2_2.10.0-1_amd64.deb": "d0ffc213203186c84facb57463fe120a12d75c5a2fc360a469bd42c8c349f53a",
+    "libvdpau1_1.4-3_amd64.deb": "056cf72eb36a22f462ce99caa7a7a97e1b5e54af23478192d25d4b007e8056c9",
+    "libvisual-0.4-0_0.4.0-17_amd64.deb": "083be3fb1dae77f7b464b0c6d742e090b82e50dc3fac73cdf241506dc85f5d75",
+    "libvo-aacenc0_0.1.3-2_amd64.deb": "58677862f52f5246ed2f77c0329552b5a2ee714989044a1e1790cb373d0fa90b",
+    "libvo-amrwbenc0_0.1.3-2_amd64.deb": "815f2faad7f72ae6e405a7a33974a545babd194633263a7e63e02bbadff162ad",
+    "libvorbis0a_1.3.7-1_amd64.deb": "01c14f9d1109650077a4c5c337c285476a6932d4d448f5a190c2b845724dbf21",
+    "libvorbisenc2_1.3.7-1_amd64.deb": "75dd4d6f904c7db82f5112e60d8efea9e81dfedf94e970c5da7af2b3d81643c0",
+    "libvorbisfile3_1.3.7-1_amd64.deb": "68f84034ae1c9fa0ab6a45f5b6c406a50faae4421f0d78874260aefa2df68efc",
+    "libvpx6_1.9.0-1_amd64.deb": "c2466114b2eb1a6db926f0f530f335886ad824c6add69d01fb79373c4cdd4c08",
+    "libvtk9_9.0.1+dfsg1-8_amd64.deb": "4ad702dead9093501df3efa58a138c7e23b807614f11eb8b6bffc11d1f50142f",
+    "libvulkan1_1.2.162.0-1_amd64.deb": "8b3a6e5db7d8bdc369a0d276bfae1551ffc0fa31dbd193d56655c8f553868361",
+    "libwavpack1_5.4.0-1_amd64.deb": "51e52731f4a403bd7c11d93bc9c1ded3c02772cd0972c85641f3c555c215c400",
+    "libwayland-bin_1.18.0-2~exp1.1_amd64.deb": "774e97053d524549044b332469d13eec70c989b4bc00a592019512c17a92978e",
+    "libwayland-client0_1.18.0-2~exp1.1_amd64.deb": "4baf16bb3a35823251453368ee078b6be6a14f97b05c19783b5acd4232a608ea",
+    "libwayland-cursor0_1.18.0-2~exp1.1_amd64.deb": "1b48d1d8e17a95b28a2876c7f2a95667ee1618a5f586d4dff05aeb09488172cb",
+    "libwayland-dev_1.18.0-2~exp1.1_amd64.deb": "3265bf05c0cea760d0e8f5fb5fc68b0f154911de23503e02232dfa59f6b6490c",
+    "libwayland-egl1_1.18.0-2~exp1.1_amd64.deb": "b98e636f08eca9e818e326fc8cd75810dbb50b1ed4e3586c2394e11248e29275",
+    "libwayland-server0_1.18.0-2~exp1.1_amd64.deb": "1df9a6e304bdaebdd53e1044c6eadcda95c914119e9426c2866eaa619a49c85b",
+    "libwebp6_0.6.1-2.1_amd64.deb": "52bfd0f8d3a1bbd2c25fcd72fab857d0f24aea35874af68e057dde869ae3902c",
+    "libwebpmux3_0.6.1-2.1_amd64.deb": "78486e53903cbf422dfe04a33e5481c56c82198a2bfa307f2066e616477395f5",
+    "libwebrtc-audio-processing1_0.3-1+b1_amd64.deb": "1f7a097b1d26859acbec99f94d251ddbf825e73169d4d064e95b257ad39570e9",
+    "libwildmidi2_0.4.3-1_amd64.deb": "b6d4c8f96f81d0887241e3fc9fedc46cd0c16b486a0d08ff680b1b5d1cc4f72b",
+    "libwrap0_7.6.q-31_amd64.deb": "c6aa9c653857d807cff31682b5158722e8b16eeb3cec443d34d6eba52312e701",
+    "libx11-6_1.7.2-1_amd64.deb": "086bd667fc07369472a923da015d182bb0c15a72228a5c0e6ddbcbeaab70acd2",
+    "libx11-data_1.7.2-1_all.deb": "049b7eabced516acfdf44a5e81c26d108b16e4987e5d7604ea53eaade74027fb",
+    "libx11-dev_1.7.2-1_amd64.deb": "11e5f9dcded1a1226b3ee02847b86edce525240367b3989274a891a43dc49f5f",
+    "libx11-xcb-dev_1.7.2-1_amd64.deb": "80a2413ace2a0a073f2472059b9e589737cbf8a336fb6862684a5811bf640aa3",
+    "libx11-xcb1_1.7.2-1_amd64.deb": "1f9f2dbe7744a2bb7f855d819f43167df095fe7d5291546bec12865aed045e0c",
+    "libx264-160_0.160.3011+gitcde9a93-2.1_amd64.deb": "12c940c9755d26f73c225641f4d28aadcf55aeae211e933972e00ebfd42c700d",
+    "libx265-192_3.4-2_amd64.deb": "3ebd02002d226aef70e614676774f0c0828d21b22c0743af3b277865e05fcfe7",
+    "libxau-dev_1.0.9-1_amd64.deb": "d1a7f5d484e0879b3b2e8d512894744505e53d078712ce65903fef2ecfd824bb",
+    "libxau6_1.0.9-1_amd64.deb": "679db1c4579ec7c61079adeaae8528adeb2e4bf5465baa6c56233b995d714750",
+    "libxcb-dri2-0_1.14-3_amd64.deb": "fbfc7d55fa00ab7068d015c185363370215c857ac9484d7020c2d9c38c8401b2",
+    "libxcb-dri3-0_1.14-3_amd64.deb": "4dd503b321253f210fe546aae8fe5061fc7d30015cf5580d7843432a71ebc772",
+    "libxcb-glx0_1.14-3_amd64.deb": "61ae35a71148038aad04b021b3adfa0dee4fc06d98e045ec9edfd9e850324876",
+    "libxcb-present0_1.14-3_amd64.deb": "7937af87426de2ed382ba0d6204fee58f4028b332625e2727ebb7ca9a1b32028",
+    "libxcb-render0_1.14-3_amd64.deb": "3d653df34e5cd35a78a9aff1d90c18ec0200e5574e27bc779315b855bea2ecc0",
+    "libxcb-shm0_1.14-3_amd64.deb": "0751b48b1c637b5b0cb080159c29b8dd83af8ec771a21c8cc26d180aaab0d351",
+    "libxcb-sync1_1.14-3_amd64.deb": "53e7f18c8a95b2be2024537a753b6bd914af5f4c7aeed175f61155a5a3c8fe88",
+    "libxcb-xfixes0_1.14-3_amd64.deb": "939b29a4eaad5972ba379c2b5f29cf51d7d947b10e68cc2fe96238efcd3d63c2",
+    "libxcb1-dev_1.14-3_amd64.deb": "b75544f334c8963b8b7b0e8a88f8a7cde95a714dddbcda076d4beb669a961b58",
+    "libxcb1_1.14-3_amd64.deb": "d5e0f047ed766f45eb7473947b70f9e8fddbe45ef22ecfd92ab712c0671a93ac",
+    "libxcomposite1_0.4.5-1_amd64.deb": "4c26ebf519d2ebc22fc1416dee45e12c4c4ef68aa9b2ed890356830df42b652a",
+    "libxcursor1_1.2.0-2_amd64.deb": "d9fee761e4c50572c3ce3c3965b70fcfecd277d0d7d598e102134d12757a3d11",
+    "libxdamage1_1.1.5-2_amd64.deb": "1acf6d6117929a7df346d355caeb579798d75feb7e3b3aae58a2d1af735b444f",
     "libxdmcp-dev_1.1.2-3_amd64.deb": "c6733e5f6463afd261998e408be6eb37f24ce0a64b63bed50a87ddb18ebc1699",
     "libxdmcp6_1.1.2-3_amd64.deb": "ecb8536f5fb34543b55bb9dc5f5b14c9dbb4150a7bddb3f2287b7cab6e9d25ef",
-    "libxerces-c3.2_3.2.2+debian-1+b1_amd64.deb": "486d1ec47054ca3c25796c7615ecdd431dbc045aa006ae8a36bf2b5f41375447",
-    "libxext-dev_1.3.3-1+b2_amd64.deb": "86ffd581902086ab0bf4381b28d8fbe66fc378de2db02a96a25705eeabee0c7b",
-    "libxext6_1.3.3-1+b2_amd64.deb": "724901105792e983bd0e7c2b46960cd925dd6a2b33b5ee999b4e80aaf624b082",
-    "libxfixes-dev_5.0.3-1_amd64.deb": "ea11a513c722e0587f4bf0d1433cb9825acbdf7a873a6fe82c7b8d9dd23ff738",
-    "libxfixes3_5.0.3-1_amd64.deb": "3b307490c669accd52dc627ad4dc269a03632ca512fbc7b185b572f76608ff4e",
+    "libxerces-c3.2_3.2.3+debian-3_amd64.deb": "82aedc43835e2b7da8e12fe12a8a53e0c66c422e3881dcf8c2edcf2e4e8c658e",
+    "libxext6_1.3.3-1.1_amd64.deb": "dc1ff8a2b60c7dd3c8917ffb9aa65ee6cda52648d9150608683c47319d1c0c8c",
+    "libxfixes3_5.0.3-2_amd64.deb": "58622d0d65c3535bd724c4da62ae7acb71e0e8f527bcbd65daf8c97e6f0ef843",
     "libxft2_2.3.2-2_amd64.deb": "cd71384b4d511cba69bcee29af326943c7ca12450765f44c40d246608c779aad",
-    "libxi6_1.7.9-1_amd64.deb": "fe26733adf2025f184bf904caf088a5d3f6aa29a8863b616af9cafaad85b1237",
+    "libxi6_1.7.10-1_amd64.deb": "4d583f43b5396ca5434100a7274613e9983357d80875a47b29a4f3218fe0bec0",
     "libxinerama1_1.1.4-2_amd64.deb": "f692c854935571ee44fe313541d8a9f678a4f11dc513bc43b9d0a501c6dff0bd",
-    "libxkbcommon0_0.8.2-1_amd64.deb": "a93729f1d325598ad9c6a7ffe00c464fbe276181a3a124855041c1e303175f0c",
-    "libxml2_2.9.4+dfsg1-7+b3_amd64.deb": "401c65a9d435a26d1f9ea6e58be55253f5c3a9e32610e23edd3e103cc4ada0b4",
+    "libxkbcommon0_1.0.3-2_amd64.deb": "d74d0b9f0a6641b44c279644c7ac627fa7a9b92350b7c6ff37da94352885bcfc",
+    "libxml2-dev_2.9.10+dfsg-6.7+deb11u1_amd64.deb": "b70e2a592fe6239ec00ec6293e706608d6f29b5090cd5f2a399f7e883dac1afe",
+    "libxml2_2.9.10+dfsg-6.7+deb11u1_amd64.deb": "c4335b83890d05760f455393c0ddd9406056d46cebe59c6de4a2876f2db04847",
     "libxpm4_3.5.12-1_amd64.deb": "49e64f0923cdecb2aaf6c93f176c25f63b841da2a501651ae23070f998967aa7",
     "libxrandr2_1.5.1-1_amd64.deb": "8fdd8ba4a8ad819731d6bbd903b52851a2ec2f9ef4139d880e9be421ea61338c",
     "libxrender1_0.9.10-1_amd64.deb": "3ea17d07b5aa89012130e2acd92f0fc0ea67314e2f5eab6e33930ef688f48294",
-    "libxshmfence-dev_1.3-1_amd64.deb": "7fcd7bb466a106e6f79a0cdf403559857c0fc20e6a55bdc2b963cfccee0256f9",
     "libxshmfence1_1.3-1_amd64.deb": "1a38142e40e3d32dc4f9a326bf5617363b7d9b4bb762fdcdd262f2192092024d",
     "libxss1_1.2.3-1_amd64.deb": "85cce16368f08a878fa892fbc54520fc654d00769cde6d300b8b802734a993c0",
-    "libxt6_1.1.5-1+b3_amd64.deb": "5c474aa7c6bef9c8b0a4cf5cb9102c29ba8c5b2b19a59269ab6e2f0a47a5ec59",
-    "libxvidcore4_1.3.5-1_amd64.deb": "da357124b48e97c7c55d836b093688ef708de7446a6ba1c54708f1307f7b7a16",
-    "libxxf86vm-dev_1.1.4-1+b2_amd64.deb": "2fb753a7c2c2fd6b74b8429d180b259af9c2b4201f8c777621ac88c63d43cea7",
+    "libxvidcore4_1.3.7-1_amd64.deb": "048e4d456992c7f593564e8ad1cecfc4be0464bfb1fc7a8908a643d59d9fbe81",
     "libxxf86vm1_1.1.4-1+b2_amd64.deb": "6f4ca916aaec26d7000fa7f58de3f71119309ab7590ce1f517abfe1825a676c7",
-    "libzstd1_1.3.8+dfsg-3_amd64.deb": "0f780477b30c7996ca370563aee75117531cea64182f847583ee7028a4d7a2e8",
-    "libzvbi-common_0.2.35-16_all.deb": "5eea3f86857626ce4371a8a70ba9ce89f1abfc47ed033d1de12ebc0c7d1dd3ea",
-    "libzvbi0_0.2.35-16_amd64.deb": "8f4a22c99ed7dce92964b8635574701753bffedf44c78704f701f895f78f2604",
-    "lsb-base_10.2019051400_all.deb": "2dd69416c4e8decda8a9ed56e36275df7645aea7851b05eb16d42fed61b6a12f",
-    "mariadb-common_10.3.22-0+deb10u1_all.deb": "54fb0fcefe4c0e74e6ad57cea0f47d5b585c2e9597423d8f0205aee8b0982975",
-    "mesa-common-dev_18.3.6-2+deb10u1_amd64.deb": "7b195dd2a78cdd5ad9979212f3757916a61b41c1016d05b3c1a4382344635664",
-    "mime-support_3.62_all.deb": "776efd686af26fa26325450280e3305463b1faef75d82b383bb00da61893d8ca",
-    "mysql-common_5.8+1.0.5_all.deb": "340c68aaf03b9c4372467a907575b6a7c980c6d31f90f1d6abc6707a0630608a",
-    "ocl-icd-libopencl1_2.2.12-2_amd64.deb": "f6841f09eb7b30d5c77b8ff07c2d0051f1c2ca201fdb86ae7a7afdbcd76a463a",
-    "odbcinst1debian2_2.3.6-0.1_amd64.deb": "9faa42382d24940361117a44ad7e95c5cc556a79e1a3623aeba4e9dfc1057fd1",
-    "odbcinst_2.3.6-0.1_amd64.deb": "b355185cb8559b8c1e733874c37c5ffc73431122b04ffb5264db59654e99aad6",
-    "passwd_4.5-1.1_amd64.deb": "23af4a550da375cefbac02484e49ed1c2e6717c0f76533137b3f2fa2cc277cf2",
-    "perl_5.28.1-6_amd64.deb": "dcd5b010f41c636822e8d4e51ccee48d66dd3cc663a61cc316ac489887e210e2",
-    "pkg-config_0.29-6_amd64.deb": "61fc3d4e34671d05f097e4aee5c03223b66de4fcbc76887ad1dbc55885c3965b",
-    "proj-data_5.2.0-1_all.deb": "fa7126aa00742ccf75f0e9867b54ea70f733436b97f600bec39408c5d3c54bd2",
-    "python3-distutils_3.7.3-1_all.deb": "6918af11061d3141990e78f5ad0530ec0f9a188cac27113d9de2896203efc13f",
-    "python3-lib2to3_3.7.3-1_all.deb": "227e2a2d12922c00dee9e55d8c5b889cfc5e72a54b85c2a509fa1664c2e9e137",
-    "python3-minimal_3.7.3-1_amd64.deb": "9c937923b35ac24f5cb6be81626f00dd6b810fc0889e5b3b08b7ffc9d179ff1b",
-    "python3.7-minimal_3.7.3-2+deb10u1_amd64.deb": "b5501e882d51b5f39c0d2858750a4d479072b24cd48adfbd42727331abb3426d",
-    "python3.7_3.7.3-2+deb10u1_amd64.deb": "c4fe8e46da0c8dccee47780993709c2ede46cc32d720a5f673e295fb68a9e640",
-    "python3_3.7.3-1_amd64.deb": "eb7862c7ad2cf5b86f3851c7103f72f8fa45b48514ddcf371a8e4ba8f02a79e5",
-    "readline-common_7.0-5_all.deb": "153d8a5ddb04044d10f877a8955d944612ec9035f4c73eec99d85a92c3816712",
-    "sensible-utils_0.0.12_all.deb": "2043859f8bf39a20d075bf52206549f90dcabd66665bb9d6837273494fc6a598",
-    "shared-mime-info_1.10-1_amd64.deb": "6a19f62c59788ba3a52c8b08750a263edde89ac98e63c7e4ccfb14b40eafaf51",
-    "ttf-bitstream-vera_1.10-8_all.deb": "328def7f581bf94b3b06d21e641f3e5df9a9b2e84e93b4206bc952fe8e80f38a",
-    "tzdata_2019c-0+deb10u1_all.deb": "59b295b0e669af26d494ed2803eb9011408f768a77395db2573e67c388e8a509",
-    "ucf_3.0038+nmu1_all.deb": "d02a82455faab988a52121f37d97c528a4f967ed75e9398e1d8db571398c12f9",
-    "uuid-dev_2.33.1-0.1_amd64.deb": "68ddfcc9e87d448b646dab275eef9dbf3eac9ac8187c38fa0e66faf6182fecdc",
-    "x11-common_7.7+19_all.deb": "221b2e71e0e98b8cafa4fbc674b3fbe293db031c51d35570a3c8cdfb02a5a155",
-    "x11proto-core-dev_2018.4-4_all.deb": "8bdb72e48cac24f5a6b284fea4d2bd6cb11cbe5fba2345ce57d8017ac40243cb",
-    "x11proto-damage-dev_2018.4-4_all.deb": "33b9b97e107f01f537108143aca6c087eef71ebf46c0f2dd3194b02bf3ef6450",
-    "x11proto-dev_2018.4-4_all.deb": "aa0237467fcb5ccabf6a93fc19fae4d76d8c6dfbf9e449edda5f6393e50d8674",
-    "x11proto-fixes-dev_2018.4-4_all.deb": "c4bb58f037c0de0ccd9c1021c3bd89de9236f5ac0db64fcd4cb8b636b14a5d64",
-    "x11proto-input-dev_2018.4-4_all.deb": "364edce8bb7cf3187c1e81d37ea5b8f6b6ddd3a74c4c82efa1810dd451bbddbf",
-    "x11proto-kb-dev_2018.4-4_all.deb": "14df9b61bf65d8cb8b6053c2bc8f993454e8076d2a5ebc4e8d2bfe671c0592e3",
-    "x11proto-xext-dev_2018.4-4_all.deb": "fd5c04fa8f10bdaeadb7bde8b14534265b38fdf18de708476eefcb229a70cbc0",
-    "x11proto-xf86vidmode-dev_2018.4-4_all.deb": "ab251198b55dc453015a596ed3195e7ad8a5b930f0baf4b68b72e0104c9c1501",
-    "xkb-data_2.26-2_all.deb": "17d21564c940dd8d89e0a1b69d6fea0144d057e4698902378f5c83500612b779",
-    "xorg-sgml-doctools_1.11-1_all.deb": "359dc76bf7b19fbbdb0b9e3ca3077e415b5b9ca8ff85162ccc889f9974493600",
-    "xtrans-dev_1.3.5-1_all.deb": "cadb720a2f8f0a2b2ad2dd82172d59e105e37885cedb3a93f6de9c78478c72d0",
-    "zlib1g_1.2.11.dfsg-1_amd64.deb": "61bc9085aadd3007433ce6f560a08446a3d3ceb0b5e061db3fc62c42fbfe3eff",
-    "zlib1g-dev_1.2.11.dfsg-1_amd64.deb": "ad2fa6d373ab18c3fc729e3a477e8b999ad33480170bd0d8966e9c7fd4843837",
+    "libz3-4_4.8.10-1_amd64.deb": "7a38c2dd985eb9315857588ee06ff297e2b16de159dec85bd2777a43ebe9f458",
+    "libzbar0_0.23.90-1_amd64.deb": "400c37e4eedf8875e39a594c8329962362eb806643dd53d4691fbf0599720eea",
+    "libzmq5_4.3.4-1_amd64.deb": "817977deef176bd5be517690ae56c136cfcc2667ed434b2a8e43ac87437e9926",
+    "libzstd1_1.4.8+dfsg-2.1_amd64.deb": "5dcadfbb743bfa1c1c773bff91c018f835e8e8c821d423d3836f3ab84773507b",
+    "libzvbi-common_0.2.35-18_all.deb": "53ed21370b937a9385e1fcf1626400891bd4fd86a76b31654fb45e0875d8bfb8",
+    "libzvbi0_0.2.35-18_amd64.deb": "41ce82a1c9b629385d837970afaa7aefffb2c923fc54b31ebf582e0d905b9cdd",
+    "libzxingcore1_1.1.1-2_amd64.deb": "306a362b6ca238856a2c02e08f57a5ef21db570c2a7e5f9c5123737a9ac62e49",
+    "lsb-base_11.1.0_all.deb": "89ed6332074d827a65305f9a51e591dff20641d61ff5e11f4e1822a9987e96fe",
+    "mariadb-common_10.5.15-0+deb11u1_all.deb": "a98b12228a79f29c588cb621f0fee395b263fcfc5037b912a22e8b168be3550d",
+    "mysql-common_5.8+1.0.7_all.deb": "22b3130e002c2c2fa6a1124aaccbe3a6ddbbb4d6bf03beed8a6f044027dcb720",
+    "ocl-icd-libopencl1_2.2.14-2_amd64.deb": "fb5624009f0f8015eef1d28c4f88046abc72f093a4a508894f5c043b3e16bcef",
+    "odbcinst1debian2_2.3.6-0.1+b1_amd64.deb": "127e6d2728921dd270e60fae11b0175c2d49fcd0c4845e803c0819dc6e5dc175",
+    "odbcinst_2.3.6-0.1+b1_amd64.deb": "112d552e88ef6fd99e717dd2dae8764fffc11a2787e7452dcc312d34c161a33e",
+    "perl_5.32.1-4+deb11u2_amd64.deb": "1cebc4516ed7c240b812c7bdd7e6ea0810f513152717ca17ce139ee0dfbc7b0d",
+    "pkg-config_0.29.2-1_amd64.deb": "09a05a23c5fd5baacd488255a6b0114909210691b830fb951acd276e9bcd632a",
+    "proj-data_7.2.1-1_all.deb": "40c64f7808d8233c08f3aa2745211e705828b4ae6fc5dbd62a934d8c3e9fd6e5",
+    "python3-distutils_3.9.2-1_all.deb": "05ec4080e0f05ba6b1c339d89c97f6343919be450b66cf4cfb215f54dcb85e58",
+    "python3-lib2to3_3.9.2-1_all.deb": "802c198e5dd0b5af85a6937e426a85d616680785e8d18148fac451281a83a9a9",
+    "python3_3.9.2-3_amd64.deb": "6d9375916c5c0d670df708bed3e8c033ce4b197a580d536ce39d1170c67a4c95",
+    "readline-common_8.1-1_all.deb": "3f947176ef949f93e4ad5d76c067d33fa97cf90b62ee0748acb4f5f64790edc8",
+    "sensible-utils_0.0.14_all.deb": "b9a447dc4ec8714196b037e20a2209e62cd669f5450222952f259bda4416b71f",
+    "shared-mime-info_2.0-1_amd64.deb": "de0a814e186af5a941e1fcd3044da62eb155638fcf9616d6005bcfc6696bbe67",
+    "timgm6mb-soundfont_1.3-5_all.deb": "034abdfb296d9353433513dad5dbdcab46425ee6008fc02fe7039b46e75edc54",
+    "ttf-bitstream-vera_1.10-8.1_all.deb": "ba622edf73744b2951bbd20bfc113a1a875a9b0c6fed1ac9e9c7f4b54dd8a048",
+    "tzdata_2021a-1+deb11u3_all.deb": "61346a9f8cda14c34251d2440c8de8dab7c09bda7ebb96533166b4567359de66",
+    "ucf_3.0043_all.deb": "ebef6bcd777b5c0cc2699926f2159db08433aed07c50cb321fd828b28c5e8d53",
+    "uuid-dev_2.36.1-8+deb11u1_amd64.deb": "90a533bbb3b82f5c9bedc5da28965ca8223913099f8ac67213e4f8828bfdd2a1",
+    "x11-common_7.7+22_all.deb": "5d1c3287826f60c3a82158b803b9c0489b8aad845ca23a53a982eba3dbb82aa3",
+    "x11proto-core-dev_2020.1-1_all.deb": "92941b1b2a7889a67e952a9301339202b6b390b77af939a26ee15c94ef4fad7e",
+    "x11proto-dev_2020.1-1_all.deb": "d5568d587d9ad2664c34c14b0ac538ccb3c567e126ee5291085a8de704a565f5",
+    "xkb-data_2.29-2_all.deb": "9122cccc67e6b3c3aef2fa9c50ef9d793a12f951c76698a02b1f4ceb9e3634e5",
+    "xorg-sgml-doctools_1.11-1.1_all.deb": "168345058319094e475a87ace66f5fb6ae802109650ea8434d672117982b5d0a",
+    "xtrans-dev_1.4.0-1_all.deb": "9ce1af9464faee0c679348dd11cdf63934c12e734a64e0903692b0cb5af38e06",
+    "zlib1g-dev_1.2.11.dfsg-2_amd64.deb": "a36b74415b32513dab9a2fa56e7d215f5e5d0185df6939e483267cef15e2eaf5",
 }
diff --git a/debian/gstreamer_arm64.bzl b/debian/gstreamer_arm64.bzl
new file mode 100644
index 0000000..cd7eb40
--- /dev/null
+++ b/debian/gstreamer_arm64.bzl
@@ -0,0 +1,523 @@
+files = {
+    "adwaita-icon-theme_3.38.0-1_all.deb": "2046876c82fc1c342b38ace9aa0661bcb3e167837c984b4bdc89702bc78df5ac",
+    "coreutils_8.32-4_arm64.deb": "6210c84d6ff84b867dc430f661f22f536e1704c27bdb79de38e26f75b853d9c0",
+    "dconf-gsettings-backend_0.38.0-2_arm64.deb": "8d1df67abd7bca93f361ca26f5bb70821c91b5c4d5924941fef524f76fc6d473",
+    "dconf-service_0.38.0-2_arm64.deb": "b76a7d724cc9f18f91cc22aff58afcb090cc7a28ec9b9a21cdd1aa069c7a4cef",
+    "fluidr3mono-gm-soundfont_2.315-7_all.deb": "4098301bf29f4253c2f5799a844f42dd4aa733d91a210071ad16d7757dea51d6",
+    "fontconfig-config_2.13.1-4.2_all.deb": "48afb6ad7d15e6104a343b789f73697301ad8bff77b69927bc998f5a409d8e90",
+    "fontconfig_2.13.1-4.2_arm64.deb": "166e5e6d47af2e1a48eff6fb66e89f0e6e0f390d04f7c9abe8b4f36812378267",
+    "fonts-croscore_20201225-1_all.deb": "64904820b729ff40038f85683004e3b94b328d969bc0fbba263c58d635452923",
+    "fonts-dejavu-core_2.37-2_all.deb": "1f67421437b6eb18669d2868e3e02cb88668683d635198142f48aacc5b397118",
+    "fonts-freefont-otf_20120503-10_all.deb": "0b63996c80c6c660424af6d3832818e647960d6f65a51de010bb57dd0762faa7",
+    "fonts-freefont-ttf_20120503-10_all.deb": "4ca1c21ebc479198a3a5879d236c8317d6f7b2f1c403f7890e24c02eead05615",
+    "fonts-liberation2_2.1.3-1_all.deb": "e0805f0085132f5e6dd30f88c0d7260caf1e5450832fe2e3988a20fa9fa2150e",
+    "fonts-liberation_1.07.4-11_all.deb": "efd381517f958b01969343634ffcbdd60056be7779af84c6f53a005090430204",
+    "fonts-texgyre_20180621-3.1_all.deb": "cb7e9a4b2471cfdd57194c16364f9102f0639816a2662fed4b30d2a158747076",
+    "fonts-urw-base35_20200910-1_all.deb": "f95a139adb7f1b60626e76d4d45d1b35aad1bc2c2597394c291ef5f84b5dcb43",
+    "gdal-data_3.2.2+dfsg-2+deb11u1_all.deb": "3ae44cc2f51dccc023f9c3cfbea3411508e24f1335651fa0e6cba74b7b9b87aa",
+    "gir1.2-glib-2.0_1.66.1-1+b1_arm64.deb": "c169be0e2d5429521f2a306f5e8359489007cd5fb2ba13ce7b8df82c8c917075",
+    "gir1.2-gst-plugins-bad-1.0_1.20.1-1~bpo11+1_arm64.deb": "ecbfa3ee7bed8783488441414eaab0f205475ce08c17a898539a5177b7c6f69b",
+    "gir1.2-gst-plugins-base-1.0_1.20.1-1~bpo11+1_arm64.deb": "31284a7c37c293c93e2c772b5838bad45a6a03802949de260a92f5d32103a1ea",
+    "gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_arm64.deb": "7cf47e2dc53bda3f98307acefcfe14a3b1751128302408c6794b4fcaee1daa61",
+    "gir1.2-gudev-1.0_234-1_arm64.deb": "0b150144ae6bff0fcaadc8aa47232809db948aef2faacbdaaf49217cc31e9a89",
+    "gir1.2-json-1.0_1.6.2-1_arm64.deb": "f21ff7ca42b997bc178d20b997b7a0d6e4a8ab9ae24c8d9b4953dd0525c5de4d",
+    "gir1.2-soup-2.4_2.72.0-2_arm64.deb": "bc3f96d1bf587783c21048562322533742f7bc8f4b1384233512cf9af4a07a0a",
+    "glib-networking-common_2.66.0-2_all.deb": "a07370151ce5169e48ee7799b9bd9a7a035467a21f5cf3373b2aff090968609c",
+    "glib-networking-services_2.66.0-2_arm64.deb": "7fc232a31f09d8d08242ce08f53286e3b296c7b146834cdb41da75303f5417e1",
+    "glib-networking_2.66.0-2_arm64.deb": "3da5e3ba93a1e9a18a4cb14cfda44f938b270291004f0e88fa7d6316dfc9aebb",
+    "gsettings-desktop-schemas_3.38.0-2_all.deb": "3758968491a770e50cd85122c00d141944ffb43cb7a5c886a37290fef848cee3",
+    "gstreamer1.0-nice_0.1.18-2~bpo11+1_arm64.deb": "be6baa33743f6ba35ed3f2e51b08c9c3437094a1beb975bd2aba2f0c1b7ae9df",
+    "gstreamer1.0-plugins-bad_1.20.1-1~bpo11+1_arm64.deb": "2d29b5ae1986c3da45014986b3ed7be2da8a7179a9f75daa086280d7e66e45b9",
+    "gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_arm64.deb": "b1939a662a68e156edc89b061cee211f586284801f95849b222d2cc65161e480",
+    "gstreamer1.0-plugins-good_1.20.1-1~bpo11+1_arm64.deb": "09b1019953106ebb22904f1694f9f6352395ff815716b31b1fc5619d9ee52d29",
+    "gstreamer1.0-plugins-ugly_1.20.1-1~bpo11+1_arm64.deb": "b5e8a9ac30e154daef5073fec33d2d95d6eba651f64a0cb867d63e627397e664",
+    "gtk-update-icon-cache_3.24.24-4+deb11u2_arm64.deb": "4353a51918639f6adc45b185f06caf14f461e435b3d32e26ed2607d1e786938f",
+    "hicolor-icon-theme_0.17-2_all.deb": "20304d34b85a734ec1e4830badf3a3a70a5dc5f9c1afc0b2230ecd760c81b5e0",
+    "icu-devtools_67.1-7_arm64.deb": "17c0c7d5e1fc10b954aafd7b76474c1d648b3b4034f969bada31195da9a49d59",
+    "iso-codes_4.6.0-1_all.deb": "4e044d72a9f810aabf2c8addf126327fa845eaf8e983b51eb6356b9ed5108348",
+    "liba52-0.7.4_0.7.4-20_arm64.deb": "663eff94315dd15f0531f9a8b92f1778222faa93ebd92c48065246202975cbc8",
+    "libaa1_1.4p5-48_arm64.deb": "507fd5a5b659ac8116a14ee15fed17086aeb43903965d1adcdf053d2682c2eb1",
+    "libaec0_1.0.4-1_arm64.deb": "d71f8f3448d2aa6df31707bb97db9b307305011f9e3ae19a270f2a8858657a45",
+    "libaom0_1.0.0.errata1-3_arm64.deb": "600536f50bf36cbcfabfc8eacb43a8f26bff7a8f8f52304ce35fc1a117dcd06e",
+    "libarchive13_3.4.3-2+deb11u1_arm64.deb": "20ac2c3a178375fd35d17d1621f387461fe530d593970d505985fa4b229df760",
+    "libarmadillo10_10.1.2+dfsg-6_arm64.deb": "d937aa4788605c00a4cb6e1bfcc233ab53981761e7f04cc6b1c324607f397bbe",
+    "libarpack2_3.8.0-1_arm64.deb": "d9baf93cd93b528c331f9fd23ed0ad8fa901cd15ff6b07c914ceffa051eb02fe",
+    "libasound2-data_1.2.4-1.1_all.deb": "76211f5f201ad1069b95d047863e0c1b51d8400c874b59e00f24f31f972b4036",
+    "libasound2_1.2.4-1.1_arm64.deb": "8fabd77256593c42e2ad1578f938b56d0a5ed19aa61c6c72c890fd761fd129a8",
+    "libass9_0.15.0-2_arm64.deb": "01a4324d10e612584f90e246a1376909983866fa24b4bb6b8fb7bf1c61f71d57",
+    "libasyncns0_0.8-6+b2_arm64.deb": "1988ed1b9d48baae39a5ca37416579a8422e687e11df18b540fa28247868935f",
+    "libatk-bridge2.0-0_2.38.0-1_arm64.deb": "a977c4a2be6d46185cd4f529ba226017dfcdc9a4056ff80ae97f7c67799885b2",
+    "libatk1.0-0_2.36.0-2_arm64.deb": "53c9c45ba719f1df44f5477396d276530e7e2fc210bc598e48e624194b8a1173",
+    "libatk1.0-data_2.36.0-2_all.deb": "86c1acae473977f8a78b905090847df654306996324493f9a39d9f27807778b2",
+    "libatspi2.0-0_2.38.0-4_arm64.deb": "ca3db48d64bdd6f6e26931a5d52ddb73bc6d915957a678bc2779e03aeacf467b",
+    "libattr1_2.4.48-6_arm64.deb": "cb9b59be719a6fdbaabaa60e22aa6158b2de7a68c88ccd7c3fb7f41a25fb43d0",
+    "libavahi-client3_0.8-5_arm64.deb": "b255f51854f9984a9e69a52bbce6cab5ce6141ed7dc232cc810053c228514ce3",
+    "libavahi-common-data_0.8-5_arm64.deb": "59e6d7f43ab387989e4cb116fe35292e07cb6e6a9125b944acd417c288f88f35",
+    "libavahi-common3_0.8-5_arm64.deb": "bd51e2159b0350ffbaf653f44131ce522f0a6eeab0d60c2ccd72182a0001cb5b",
+    "libavc1394-0_0.5.4-5_arm64.deb": "5a6ad45da10d69ca6ca7757882fe696ace8af98fccac781697ef280ea13e770f",
+    "libavcodec-dev_4.3.3-0+deb11u1_arm64.deb": "189dae2788f471312d20bc57587a2fda447eaf992d6ebfb63657f75254e8e424",
+    "libavcodec58_4.3.3-0+deb11u1_arm64.deb": "f86160f51ad8e2feb6bd6a4c241e9724f6e48248a7d6f54f844df08867f196a7",
+    "libavformat-dev_4.3.3-0+deb11u1_arm64.deb": "321ffce7b99458ea358112d16c803465821370328cbda19d2c3edc3c574ed7c2",
+    "libavformat58_4.3.3-0+deb11u1_arm64.deb": "1d8dcb480bf88ab3920eecbed6531210fd756748e869222e7ed9eeb1e806355f",
+    "libavutil-dev_4.3.3-0+deb11u1_arm64.deb": "c39d6ede6e43123843db5d25ae006c2e7c8cae16cc07053550d1430e62f53b86",
+    "libavutil56_4.3.3-0+deb11u1_arm64.deb": "b0e732ed95860f3098ddcfa95b52e865376a5ad279fe34fa61324e472406094c",
+    "libblas3_3.9.0-3_arm64.deb": "99806c4a490d55ae1ba50640460a2f62c491a8920af4e804560849fc5fe9d73f",
+    "libblkid-dev_2.36.1-8+deb11u1_arm64.deb": "a7ad72251fbde83e44b82e8031b72c0a439e049b05b278aa2185c4da193161a5",
+    "libblkid1_2.36.1-8+deb11u1_arm64.deb": "f6daca6d84eab01e281bf59d7c06f55125b8af443da936afdd255fa32f939928",
+    "libbluray2_1.2.1-4+deb11u1_arm64.deb": "ccc3d64b9f3d5aa37223ce9f331b137ebeb10eb26d933bf83179772d2571fb2a",
+    "libbrotli-dev_1.0.9-2+b2_arm64.deb": "969b37f09319811600eb14e628786fcc7da3687bd642f1dc82aaa2e41c6e0766",
+    "libbrotli1_1.0.9-2+b2_arm64.deb": "52ca7f90de6cb6576a0a5cf5712fc4ae7344b79c44b8a1548087fd5d92bf1f64",
+    "libbs2b0_3.1.0+dfsg-2.2+b1_arm64.deb": "a900464c3677b73ff7a05524db80f18af3bba1b3ae1bc950ea4a94b27d2000dc",
+    "libbsd0_0.11.3-1_arm64.deb": "b6e7fa54a05e5a3a5e1ec5dceb57a470e9a0883081594aea643ca58264071e7a",
+    "libcaca0_0.99.beta19-2.2_arm64.deb": "83e458423ee3314cc9c28d91105fbd80377dbca763e9fca92f50d1b747a50cb0",
+    "libcairo-gobject2_1.16.0-5_arm64.deb": "971311ba4fa99a4611205b2f7fbb8278b3798faf3409336e6f0b0d32106f7b7b",
+    "libcairo2_1.16.0-5_arm64.deb": "5b18336974b045dda5fbd64799f06247f6b216ee54f3391adc90f0bf81596de5",
+    "libcap2-bin_2.44-1_arm64.deb": "37915f4cc73cfaef7862043f2bdad062d1b1639df04c511665f1f9321c84d0db",
+    "libcap2_2.44-1_arm64.deb": "7c5729a1cfd14876685217c5f0545301e7ff1b839262fb487d6a778e8cd8c05a",
+    "libcdio19_2.1.0-2_arm64.deb": "97b69a7b22d2b924388665d3227a64bc99936b2ad1168683b2cbefa142861af8",
+    "libcdparanoia0_3.10.2+debian-13.1_arm64.deb": "9c3886d3bbea3311fdd7051b9f2fbee54f4f88dba19c1da0cf2c9ae22679f048",
+    "libcfitsio9_3.490-3_arm64.deb": "b538f9fedc7055a6b878f4de16e0a6de96a26c3e03ddc857aeda22da946be7d8",
+    "libcharls2_2.2.0+dfsg-2_arm64.deb": "bbbf7b985fd559d4fb6226dd04a35eb745bbd22285bea98e2550cef785ff55ac",
+    "libchromaprint1_1.5.0-2_arm64.deb": "b2462da2f97fdd9ff14861451309ce3d86c4a579422c41dbdf858b2d1cfd237d",
+    "libcodec2-0.9_0.9.2-4_arm64.deb": "325c2106a587e3c054b31cf6ab8325f61a32f141eee2cea3f2eaa0423b3398d5",
+    "libcolord2_1.4.5-3_arm64.deb": "6b0d8c1debb73d9d4a97f38804e46e384d28869c6d4458d5fe807d207eecf7a6",
+    "libcups2_2.3.3op2-3+deb11u1_arm64.deb": "5badecf1e5c921ae50584378af49e4e185221e855d209ba9f2c4955d825de06d",
+    "libcurl3-gnutls_7.74.0-1.3+deb11u1_arm64.deb": "8e8ae4b7c49ff981aab871069a6457f3413d3648597b26c73500cbe7474141c4",
+    "libcurl4_7.74.0-1.3+deb11u1_arm64.deb": "1ec03ae6ededc45d9bc0906259e72ec27dd91d6d4b50e69904a5c1de13606176",
+    "libdap27_3.20.7-6_arm64.deb": "0df6382891cf0196c94d3d3edfb85991c85cc0345aa007011b69be5f3afce520",
+    "libdapclient6v5_3.20.7-6_arm64.deb": "12dd444ba9a7e2f4949af376dc874cd0cf2bdcb6fc15beba0855de0b8d861088",
+    "libdatrie1_0.2.13-1_arm64.deb": "e2953eec7abf0addebb53d6690a5b52b0e8429492328636e495ce016d819c4c7",
+    "libdav1d4_0.7.1-3_arm64.deb": "4ec26df2faceb35a9d0d821e4ad4a15ff899b07dea83263ccd51d38c57d8c760",
+    "libdb5.3_5.3.28+dfsg1-0.8_arm64.deb": "cf9aa3eae9cfc4c84f93e32f3d11e2707146e4d9707712909e3c61530b50353e",
+    "libdbus-1-3_1.12.20-2_arm64.deb": "2c8e07966435aae522bca50c4d699d940b34931f7906202e83b36982d9783c2b",
+    "libdc1394-25_2.2.6-3_arm64.deb": "09ba9019e1797379a0b662fe24309887a2c6c3e6e8de32f6e33704c65bccdbd4",
+    "libdc1394-dev_2.2.6-3_arm64.deb": "947c7302121d61af8e8b7dfdde910bc2b4342d239fbf5da719bc1b37dc7b5174",
+    "libdca0_0.0.7-2_arm64.deb": "3263ecd4b5aed7031bce65daa7883a1e10c1084e67b10874925d862495809a83",
+    "libdconf1_0.38.0-2_arm64.deb": "c89b11d34fbba55da7fc8a43fda7975eec59cd1b65695d485b7139815c44fb65",
+    "libde265-0_1.0.8-1_arm64.deb": "34097553c0c1075d16e59a8514f318000e26961592e135bf9c0f742a49f9f7d8",
+    "libdeflate-dev_1.7-1_arm64.deb": "782494693fb9e1306dfd0933f16d3be46fb1295666f3f7665a585555fddcf842",
+    "libdeflate0_1.7-1_arm64.deb": "a1adc22600ea5e44e8ea715972ac2af7994cc7ff4d94bba8e8b01abb9ddbdfd0",
+    "libdouble-conversion3_3.1.5-6.1_arm64.deb": "63b41ee55d95505e4dcd7ec6f7bb840fdc5a0527f6ecd29069f6ce7ff8536ba2",
+    "libdpkg-perl_1.20.9_all.deb": "134bd00e60fa30d39d5f676d306d6f1d61c7f6ec6086c1785dbc355ce6190f29",
+    "libdrm-amdgpu1_2.4.104-1_arm64.deb": "660f8dced02cb67826e61a91e09101d70c904ff0231d6696d6b45dbd789e86cb",
+    "libdrm-common_2.4.104-1_all.deb": "60c69026fb8e4cfdf8d80a4a86ee30516c611dcc4de4aa1c8ccbf06dff563e2b",
+    "libdrm-dev_2.4.104-1_arm64.deb": "dbbbc3d05b470d6d35b5f2daed4be893e41b74f9c7e58bf5be3d18849b14f78a",
+    "libdrm-etnaviv1_2.4.104-1_arm64.deb": "94871c2b1fa6ad6dadff5606a293bb3d86faa2215440da9340645d3e303b82c9",
+    "libdrm-freedreno1_2.4.104-1_arm64.deb": "753c888e556952a47bbbfb85823f80eaefa0b23cd8131c69667cbb7c0af13b87",
+    "libdrm-nouveau2_2.4.104-1_arm64.deb": "d54e628289717d6751367767e9b1867ed8b863890a64724cda4e76f3be773cde",
+    "libdrm-radeon1_2.4.104-1_arm64.deb": "e8ecdbc425f3ce293d85eb43bd759f657db9eccef24637c4edb36a147fed93cb",
+    "libdrm-tegra0_2.4.104-1_arm64.deb": "58795c9786d0c925f89724885fc19f1d3bd55126abe7878f0f4766b6b58a7476",
+    "libdrm2_2.4.104-1_arm64.deb": "1dc606aa361307a8c5277c2a5ddedea40a4125874e887c98e82b33dacaa853b0",
+    "libdv4_1.0.0-13_arm64.deb": "cd32532a1ded7f2a159ade41db771845572271a1986b8d6af1ac2ff1c5d507ba",
+    "libdvdnav4_6.1.0-1+b1_arm64.deb": "7f62541bc9116c2074d5f89ddbdf16310ea2d37fe831bea5b2b27940218da335",
+    "libdvdread8_6.1.1-2_arm64.deb": "0a8acd661ee3e12b7c5b484fdce8e98d7d4f42f9714a5e6ca0f1d00927956d16",
+    "libdw-dev_0.183-1_arm64.deb": "368b551d30eeffcd726a3b2d9c6dad17a3dc290a422c19b6dd885523e2d0df57",
+    "libdw1_0.183-1_arm64.deb": "66805e4b00001a0e76ea5291705942b542be53e8d1149867cfbd4cd5fd92285f",
+    "libedit2_3.1-20191231-2+b1_arm64.deb": "43cbfd69ef591a66cfd06aedf930e3fc3c370b3a7ad514a33399d0e1a4d7343e",
+    "libegl-dev_1.3.2-1_arm64.deb": "e2ad8f861b423620dd202ee6dbd1f79ff09e427656d84b395cb19ff43cc77f2d",
+    "libegl-mesa0_20.3.5-1_arm64.deb": "cf0ea87393d134d49145798357725a044c80ee2d48fc8920490e15282aa4dca5",
+    "libegl1_1.3.2-1_arm64.deb": "4b531a79399010d3377ce9b6094c8f5f3508bd18ea5b32008a6a1ec16e019a81",
+    "libelf-dev_0.183-1_arm64.deb": "cf209e957183f4c00d4144069450b9dd937a61e9523bd4952c1b8ea63e983d2b",
+    "libelf1_0.183-1_arm64.deb": "12e14110cd66b3bf0564e3b184985b3e91c9cd76e909531a7f7bd2cb9b35a1f3",
+    "libepoxy0_1.5.5-1_arm64.deb": "cc66fbfd7b08de406873d792b07f17e19e70e37c8255fe33335b57d17379fdd5",
+    "libepsilon1_0.9.2+dfsg-5_arm64.deb": "d39e9ac0d3fe3fc6824c902f9085b70d70af2b40ff4a395bea8937e15516b619",
+    "libexif-dev_0.6.22-3_arm64.deb": "9b002b7311fa12eb59366f77e8c6de17932fad1f7c441f7eec91da2addbd8cd3",
+    "libexif12_0.6.22-3_arm64.deb": "2b2f428d688630275822104dad11d08203640076e91ea2df37dabcf2a6ae7e0e",
+    "libexpat1_2.2.10-2+deb11u3_arm64.deb": "d9bae74ea4fed5a5616c4acf67914a12d485fa50be729468cfbc5d2d54c91cfc",
+    "libfaad2_2.10.0-1_arm64.deb": "bd2fb8e6b423f68588c70584ea1ebc63e6960554be0f07f7198711de84120387",
+    "libffi-dev_3.3-6_arm64.deb": "31166c3c814374c520e4c47cc779291888a2a7eca09fc93b5d2918bd7e2ed085",
+    "libffi7_3.3-6_arm64.deb": "eb748e33ae4ed46f5a4c14b7a2a09792569f2029ede319d0979c373829ba1532",
+    "libflac8_1.3.3-2+deb11u1_arm64.deb": "8da72b767f4c2c30029f31f41d76549d73d0d95a6252e0fef6d144acaedbd7f9",
+    "libflite1_2.2-2_arm64.deb": "263e423db8223ee49b40fedacf64a0c86e0d64e359976fc3582e3961a5c105e7",
+    "libfluidsynth2_2.1.7-1.1_arm64.deb": "58c810eadac43ea2cc50483b851ac02692f6e8373671a34b7a02debbfba4efc1",
+    "libfontconfig1_2.13.1-4.2_arm64.deb": "18b13ef8a46e9d79ba6a6ba2db0c86e42583277b5d47f6942f3223e349c22641",
+    "libfreeaptx0_0.1.1-1_arm64.deb": "1da0a6f6af39846927078e1c5b5ed2b215b36ceeeda01d180b5fb3678a6ba512",
+    "libfreetype6_2.10.4+dfsg-1_arm64.deb": "43e3b1cc3dd70e00f930bca8b69488f5979ab358e53084361424cca7c49a3fa0",
+    "libfreexl1_1.0.6-1_arm64.deb": "8bdabfe5826a662d1082bf58bfb5d15c95082a5438f57239b9e5427b6f4701cf",
+    "libfribidi0_1.0.8-2_arm64.deb": "c6c92f3dbe2f1894b09aa1eeb74933d4dc0df6dacfadaa1ff66d96ee753d41de",
+    "libfyba0_4.1.1-7_arm64.deb": "3a7578a717d1104c55486dbd4a69271b44ce72ce0ac5d34d216417cc171a8dbb",
+    "libgbm-dev_20.3.5-1_arm64.deb": "4ef3b10914072d465282bffaa10e310dcabc88fa8ab02c200771cbe1c37f527d",
+    "libgbm1_20.3.5-1_arm64.deb": "991e5db7978e44ef745a1f7f18100927d304ddf1eaaab840167b5f07e3bdc7e8",
+    "libgcc-s1_10.2.1-6_arm64.deb": "e2fcdb378d3c1ad1bcb64d4fb6b37aab44011152beca12a4944f435a2582df1f",
+    "libgcrypt20_1.8.7-6_arm64.deb": "61ec779149f20923b30adad7bdf4732957e88a5b6a26d94b2210dfe79409959b",
+    "libgd3_2.3.0-2_arm64.deb": "1e6d6af0c90fe62193b3e51e45f69d075b86d7bde3fb4fd30b60da763aeca43f",
+    "libgdal28_3.2.2+dfsg-2+deb11u1_arm64.deb": "bc5ad6148ce06f07397f07f7a96bc865975248821fb01124184049d741e93c1a",
+    "libgdcm-dev_3.0.8-2_arm64.deb": "1795d571d83196ec248fcdfc6153fe2d21599aa1debf40ebdeec00393764ca0c",
+    "libgdcm3.0_3.0.8-2_arm64.deb": "59472494d90363690f34a7cbe3f5ba66028fab6f242161785401ba7d7c223ef7",
+    "libgdk-pixbuf-2.0-0_2.42.2+dfsg-1_arm64.deb": "e35997839534e69d093cef790dc4a43d0b102e7aed5f21492d330f810717f4ce",
+    "libgdk-pixbuf2.0-common_2.42.2+dfsg-1_all.deb": "61ff764860dafbd7e3fe2050b9c17db3ae109dea15ac748212eff56fdb3111e1",
+    "libgeos-3.9.0_3.9.0-1_arm64.deb": "9f8b32c8814c8ad72df61bc8cdf0eb95b4d625f06fb7a945e146e523c664b874",
+    "libgeos-c1v5_3.9.0-1_arm64.deb": "efffd604a25acd4088a2f34e24c779490f1389f0dd34e2b62cb1e3bc364d8ec9",
+    "libgeotiff5_1.6.0-1_arm64.deb": "94e2329dcc4236aa1bb455613f9b1795b8f8974ac40f8a77568312c677bd14fe",
+    "libgfortran5_10.2.1-6_arm64.deb": "967866fc2caf00fd28a3a515234131d7301043288b4a36e46b7dc16050a6f862",
+    "libgif7_5.1.9-2_arm64.deb": "90751dcd054948236424aac6bddc0666013621fc6d3aec9fba62e275ba12db17",
+    "libgirepository-1.0-1_1.66.1-1+b1_arm64.deb": "fb3da6c3d8b79aefa9db09fb9b5054793d5c98bab11504f41a149935849e462d",
+    "libgl-dev_1.3.2-1_arm64.deb": "cb40f975a9bf6916bb435378a1bdab4f2aec93ef4df91c7f2708900c84211e7d",
+    "libgl1-mesa-dri_20.3.5-1_arm64.deb": "13bc343bc0bb7ec8bf52ecceb2c41ac8b70bc80d4d76784252caceadf0c83b73",
+    "libgl1_1.3.2-1_arm64.deb": "18075b79c22b06bb25b9b4f3fa44a42127c40e573b34703af3f4c0b780cae29a",
+    "libgl2ps1.4_1.4.2+dfsg1-1_arm64.deb": "989c066bd91aa9ac18d9d571fba404038e25893da99c0fd86fbecda15be89372",
+    "libglapi-mesa_20.3.5-1_arm64.deb": "2678cf4bcfe4dfeba85deabaf869cb78a2f3263388baaff53e826f52cf17088b",
+    "libgles-dev_1.3.2-1_arm64.deb": "8fd9943bd37d02e0ef9e8983d880fe71aa171f2973c2c19d9fc5d9492bc13fe8",
+    "libgles1_1.3.2-1_arm64.deb": "a607c89ff8d61145f215b4be95814aef7accbfc0bac8c2a840ee9f0aca530068",
+    "libgles2_1.3.2-1_arm64.deb": "ae3fda1556b677519ff13d43295d7df678d3a9c39a21042e87d9255de1bc78b6",
+    "libglew2.1_2.1.0-4+b1_arm64.deb": "68ed07175805f1b827ff4db50387ca8dfb5bdfffa98e23c897de34706c04b42d",
+    "libglib2.0-0_2.66.8-1_arm64.deb": "667d1b891bcf9b8cc47385c19b39271c74f48fd2b6b457474184f85ce63ea261",
+    "libglib2.0-bin_2.66.8-1_arm64.deb": "e577f6ff709ecf2302515bc98b3d71d4d3e59734ae6721b8fffc1d6e4b600eb5",
+    "libglib2.0-data_2.66.8-1_all.deb": "be41a674336cefd00e2a468fe19c8bbf9f3fac86f39379e1b7acbad41f6af644",
+    "libglib2.0-dev-bin_2.66.8-1_arm64.deb": "2ca6490629d6eeb92154ea1b7d91996142a2f2ee81c91e4586d34cd9ddf581e9",
+    "libglib2.0-dev_2.66.8-1_arm64.deb": "e91666fddc4ca1a40325797ff960499ab51c3f4ab4da65ccb0ee92a1352b1f4e",
+    "libglvnd0_1.3.2-1_arm64.deb": "5d7a05a966d1df43ca440245dfc7e18a51fc974f665441fc87180a605a0481d9",
+    "libglx-dev_1.3.2-1_arm64.deb": "0a69e1f459f8bc3e190162e78f8f6aa749dfcc0ad6c77f7ec27c9b55aef8e75c",
+    "libglx-mesa0_20.3.5-1_arm64.deb": "b1f653df820ecda31ed3d6a39429befbced67093dc9b964cbfa5f7991a23eda8",
+    "libglx0_1.3.2-1_arm64.deb": "a53aec87ff8d3ae181c320c01bc190f752a276d5e5ca87e624f9058a4b520bf2",
+    "libgme0_0.6.3-2_arm64.deb": "2324dc1a5c06845f56eac43d9efb2446fb3119758eee46e793e33aa158a3325d",
+    "libgmp10_6.2.1+dfsg-1+deb11u1_arm64.deb": "d52619b6ff8829aa5424dfe3189dd05f22118211e69273e9576030584ffcce80",
+    "libgnutls30_3.7.1-5_arm64.deb": "6b7429aba5f642c258d351b2ebac5a00170f6761331f6b367edfb9401c10d8da",
+    "libgomp1_10.2.1-6_arm64.deb": "813af2e0b8ba0a7cea18c988cd843412ef6d0415700fc860d62816750e741670",
+    "libgpg-error0_1.38-2_arm64.deb": "d1116f4281d6db35279799a21051e0d0e2600d110d7ee2b95b3cca6bec28067c",
+    "libgphoto2-6_2.5.27-1_arm64.deb": "b83525eb32514b47362ab6b8c16f37f002d9a531405b1dbdaed9dd20de19b61a",
+    "libgphoto2-dev_2.5.27-1_arm64.deb": "8a13c502539d0ff3d431f5d1099c784f0ab358c81065af788d0bba65e46ba24f",
+    "libgphoto2-port12_2.5.27-1_arm64.deb": "64892ba635e3f67816748d33700262d73a0b727fd31c89c5f260eceff0c9bbea",
+    "libgpm2_1.20.7-8_arm64.deb": "367a548386f1297c937af6ed548bdcaa4db25f11c1a7495c45978826da61deb8",
+    "libgraphite2-3_1.3.14-1_arm64.deb": "473362a74ba74ae630fc43675460fb5a1058564a635a301875e00f1c6f9b27cb",
+    "libgsm1_1.0.18-2_arm64.deb": "f7ea67da4f664d6c7b49ca7f31bf6c5fee61e2ff679da61d0613efbb0fdd6cb9",
+    "libgssdp-1.2-0_1.2.3-2_arm64.deb": "817b986d52438f86709fcdbe6b8c5b55a3bcbb445c10feeb52824a95d148a322",
+    "libgstreamer-gl1.0-0_1.20.1-1~bpo11+1_arm64.deb": "fcaccf88b57203cd9a494aa60bc8db6ffb43c68525122087a6516f3ec64a2b53",
+    "libgstreamer-opencv1.0-0_1.20.1-1~bpo11+1_arm64.deb": "f4f07dfc3baa0e875e5b4298cc3cfb5749994bb56c3cb34c27ee0151a6e591e1",
+    "libgstreamer-plugins-bad1.0-0_1.20.1-1~bpo11+1_arm64.deb": "b320b3e6c6a7e6a6f5c7036e1fe986ffed90d9b65993753a8823f05fcbc09c41",
+    "libgstreamer-plugins-bad1.0-dev_1.20.1-1~bpo11+1_arm64.deb": "b653071e00823ea0f5fbfeb18d0030fc5545f0cfb329f48daa24db8f722787b6",
+    "libgstreamer-plugins-base1.0-0_1.20.1-1~bpo11+1_arm64.deb": "c0379e4c5adc551c92d8acf8bba476fea71b0c23bb135737db6f878f6403a93d",
+    "libgstreamer-plugins-base1.0-dev_1.20.1-1~bpo11+1_arm64.deb": "5a7b180a7bc2df3ded9635e126a6061789825ba9557813e4e073913fddad665a",
+    "libgstreamer1.0-0_1.20.1-1~bpo11+1_arm64.deb": "92556adf1a343a6f6a9b1b38a8c5dbdb0b16a59bb9f283a1e46c75d2376e13ca",
+    "libgstreamer1.0-dev_1.20.1-1~bpo11+1_arm64.deb": "802c4c5c358120b4f701bf9136b392537681712ecf6c2c553c6b1e7c0319123e",
+    "libgtk-3-0_3.24.24-4+deb11u2_arm64.deb": "af0df7dd4cbee8ece4b7f88c4c700f8255043bfa263a450205a0efd74162728e",
+    "libgtk-3-common_3.24.24-4+deb11u2_all.deb": "172d01f359af8f13cee93dba183e282ea5f059f2a418dfe66d35abf9dd60ddd7",
+    "libgudev-1.0-0_234-1_arm64.deb": "8e0e8990893f9355d7f725e608e948cc9369c850caf163a28f118c0262b63586",
+    "libgudev-1.0-dev_234-1_arm64.deb": "1d93b9914f0d14822d3a84ba648ecbdd6dcc421e26091a1737c6a62a18bd628c",
+    "libgupnp-1.2-0_1.2.4-1_arm64.deb": "9fc8e77b4c28caf6db825a34fa05c2dd105897e4e7213833896236326b9e64aa",
+    "libgupnp-igd-1.0-4_1.2.0-1_arm64.deb": "6852f375f22f60455552e07577c4bd75c3191f23ca2421b7968ff38671e03ee5",
+    "libharfbuzz0b_2.7.4-1_arm64.deb": "d9f0345391cc661503d1508ccd318b3db48add354e706cf9d66fa16bf99e2d03",
+    "libhdf4-0-alt_4.2.15-3_arm64.deb": "5ce23c00a3726049c74e149cf08ea46809143eb106a49e38aad973287abafdb3",
+    "libhdf5-103-1_1.10.6+repack-4+deb11u1_arm64.deb": "5f051dfa0c2f6d369e9322fa0c175717c61dce21d3bfa316e0271c949b3b834d",
+    "libhdf5-hl-100_1.10.6+repack-4+deb11u1_arm64.deb": "d3748cffd412ae9dce22016a3a4106a6e0cd2eedf79ae98a79873a0b2f64d9e7",
+    "libheif1_1.11.0-1_arm64.deb": "a8db0c9a9e0311ad2624319f1ef76e89b1c188f424adf101a581a62c28853381",
+    "libhogweed6_3.7.3-1_arm64.deb": "3e9eea5e474dd98a7de9e4c1ecfbfd6f6efb1d40bf51d6473de9713cf41d2191",
+    "libicu-dev_67.1-7_arm64.deb": "4372e38b47534a24c7d92771b805b4dcfcda8ce98489606859077ae754037257",
+    "libicu67_67.1-7_arm64.deb": "776303db230b275d8a17dfe8f0012bf61093dfc910f0d51f175be36707686efe",
+    "libidn2-0_2.3.0-5_arm64.deb": "0d2e6d39bf65f16861f284be567c1a6c5d4dc6b54dcfdf9dba631546ff4e6796",
+    "libiec61883-0_1.2.0-4_arm64.deb": "4a15ee3d12830c7bdaa5c21e522a69dabbaff3fcb4cf18648b71e37ebd0c324d",
+    "libilmbase-dev_2.5.4-1_arm64.deb": "f7efd0776113ae36e03f08d349ba7c17862746c076f54a27f366d0927579923f",
+    "libilmbase25_2.5.4-1_arm64.deb": "9d09d54ad2ceb8148fd1be0fe2e065a7c35ffecb48b329592271aaf860f620e9",
+    "libinstpatch-1.0-2_1.1.6-1_arm64.deb": "c24d1ef774b0cd16baf38f8c45d6081e38e515674cb4a5b7d27a7e853576be3e",
+    "libjack-jackd2-0_1.9.17~dfsg-1_arm64.deb": "bf6470c02225641ff4f2baaf5b724a41a175dacbc7195d90d695404ce00afdc1",
+    "libjbig-dev_2.1-3.1+b2_arm64.deb": "611c5cdf980db966432c39b8ae3cf6449f84e224e9369b7c8fe492d2d48378b1",
+    "libjbig0_2.1-3.1+b2_arm64.deb": "b71b3e62e162f64cb24466bf7c6e40b05ce2a67ca7fed26d267d498f2896d549",
+    "libjpeg-dev_2.0.6-4_arm64.deb": "ce0f75c7f632be0c980d01f2e2ae863089f99bca47e4cff3015a490e1c886d41",
+    "libjpeg62-turbo-dev_2.0.6-4_arm64.deb": "8535e4bd12e026ff79991f69c62ead5ff1750df980a20a6a7ab540587439f06f",
+    "libjpeg62-turbo_2.0.6-4_arm64.deb": "8903394de23dc6ead5abfc80972c8fd44300c9903ad4589d0df926e71977d881",
+    "libjson-c5_0.15-2_arm64.deb": "451820024e4d1023cc74758bc22beccf1aa235227026b3e24bafa67bf81d215e",
+    "libjson-glib-1.0-0_1.6.2-1_arm64.deb": "a2167dd43e00154f2418f19e819cd90db1559f78cd8d783cfac1063bba7509e8",
+    "libjson-glib-1.0-common_1.6.2-1_all.deb": "a938ec35a20dca2e5878a8750fb44683b67a5f7c2d23d383963803a9fcfac1a3",
+    "libjson-glib-dev_1.6.2-1_arm64.deb": "382233d072ddef848296465e02f5b9314dd2b57ddccb12702335f3e78484f312",
+    "libjsoncpp24_1.9.4-4_arm64.deb": "b8e04a858f2059d4e9d66b79f359995e38ff8c9509175647d6f98ba1f8b29b2a",
+    "libkate1_0.4.1-11_arm64.deb": "97890e66ff7ac0dbc99ab927ffe441feb9c51922cf6aeefd86c504e4ef9613dc",
+    "libkmlbase1_1.3.0-9_arm64.deb": "e8c4b8513c10b763ec97133bc1c6180e027aeddeaba8965cbed8fba790a8a30b",
+    "libkmldom1_1.3.0-9_arm64.deb": "301808035031ac8c3c39baf0a854a3fc4c9e4de36a45ba5cd9abf4b06cbe4432",
+    "libkmlengine1_1.3.0-9_arm64.deb": "a6cf70031c33b85d5be04d1ad0ab4ff4b580674431e1ec0ba0596017b75045cf",
+    "liblapack3_3.9.0-3_arm64.deb": "30858f2b44bd6e24100bf119ab7e4da0e9db9df1ade3957e65952d95d4c308e6",
+    "liblcms2-2_2.12~rc1-2_arm64.deb": "6d92ee1f0d427b88ab9bff32c769b61e2597c8fb289589ca0731a7e77d490d6e",
+    "libldacbt-enc2_2.0.2.3+git20200429+ed310a0-4_arm64.deb": "cf953f7b903344c29f58022894b16426488812d9ea0b8b319143d6b34c84a18c",
+    "libldap-2.4-2_2.4.57+dfsg-3_arm64.deb": "443959ae0679f73a1587e26f0f5a78e2c9909d1328c0f267c71da349dfccfe8e",
+    "liblept5_1.79.0-1.1_arm64.deb": "134c600adc419c058777f87dd5254932a03e4591e6e230a290747657d7557390",
+    "liblilv-0-0_0.24.12-2_arm64.deb": "b36dc0c3b8ba453025b4839c852065abb95c823c4c03376e9ac4db76c56d5e8b",
+    "libllvm11_11.0.1-2_arm64.deb": "0f4d1c3e259e203cc25ca5e07a4f88a018a775bdbf4376f33b06c8ffb7bb688b",
+    "libltc11_1.3.1-1_arm64.deb": "1ff780bc54ed29fd5b638fc4b1cd948c2a34524298fd32175e3abf17a6e8f81f",
+    "libltdl7_2.4.6-15_arm64.deb": "e13bc091b1493c3bbb0e6554e73bd4d913358fdcd267152d1dcb32a5a3b94e27",
+    "liblz4-1_1.9.3-2_arm64.deb": "83f0ee547cd42854e1b2a2e4c1a5705e28259ee5fa6560119f918f961a5dada2",
+    "liblzma-dev_5.2.5-2_arm64.deb": "44c7d3b32401fa0406fd9e271b10038342b7d04bba377a917847b063eb428e9b",
+    "libmariadb3_10.5.15-0+deb11u1_arm64.deb": "d54b4007c430d6d1e968e255f51475e636487942c27ec036937d45ca9e0e25ea",
+    "libmd0_1.0.3-3_arm64.deb": "3c490cdcce9d25e702e6587b6166cd8e7303fce8343642d9d5d99695282a9e5c",
+    "libminizip1_1.1-8+b1_arm64.deb": "9db7fb955cc168a591fa5cc052f02606a39333ce4b15177426baf2d956018400",
+    "libmjpegutils-2.1-0_2.1.0+debian-6_arm64.deb": "e09666538003abdb1646ea2e3f37cf6c1188e9517226fadf2feed52a184b0188",
+    "libmodplug1_0.8.9.0-3_arm64.deb": "31562caee099234947a228d6392156495b10f4b1960182e419554fe58ee50402",
+    "libmount-dev_2.36.1-8+deb11u1_arm64.deb": "46ffa87df906d4a8bcc888d14f69c70d3dd60af8383b04af452f7e3c1e49e818",
+    "libmount1_2.36.1-8+deb11u1_arm64.deb": "fd1dff93bdaba84d3f45f25448e2ada8c867674cd4e8af9fe25604ddf9a2f8de",
+    "libmp3lame0_3.100-3_arm64.deb": "ad02a132721a5569476235b3fbe8f88af0c9e06fa37d8d68f5eda604cfe8ec92",
+    "libmpcdec6_0.1~r495-2_arm64.deb": "f586bbb11f52627bf20846a501296366365ae7c1cd60c2829a8451cbf5ad2cdc",
+    "libmpeg2-4_0.5.1-9_arm64.deb": "abf6f3204f0cce6acde4b20899e58e1a5d1fa20e7dc6a138a39c3bda04e3b96d",
+    "libmpeg2encpp-2.1-0_2.1.0+debian-6_arm64.deb": "69407c9dfb3dfb441ce0083a705416eafcfd86c585f91ff5f96403eba478a7cb",
+    "libmpg123-0_1.26.4-1_arm64.deb": "4a7351593002fc11acc50d4d86a457332b6f3de488491803e1c3eafdeb440630",
+    "libmplex2-2.1-0_2.1.0+debian-6_arm64.deb": "c99fb7e85e43a59672c1dfce1c8e6256a197ab587741ab2ddaab7f287b5313f7",
+    "libncurses6_6.2+20201114-2_arm64.deb": "29e207cc49f7bedfe61f8c41d1c1878fb827df9264b3e2a9cb207998200cac4f",
+    "libncursesw6_6.2+20201114-2_arm64.deb": "4ff84101deab5af44f91df40a8220995a501c0f875f70ede51ce8c7dce7c475c",
+    "libnetcdf18_4.7.4-1_arm64.deb": "48e40a3ed8d48043996d858b8a28277f239cb43685cf13f047b3084aaeec0794",
+    "libnettle8_3.7.3-1_arm64.deb": "5061c931f95dc7277d95fc58bce7c17b1a95c6aa9a9aac781784f3b3dc909047",
+    "libnghttp2-14_1.43.0-1_arm64.deb": "317b58d2654d5875eee1dbf147ea810b8e3eb007f3bf4e2dcbca8ed76e425763",
+    "libnice10_0.1.18-2~bpo11+1_arm64.deb": "d4d1e4b44bb5e41aed8a99fd0174048bc9730b521c075c80a4aa99e30288ee83",
+    "libnorm1_1.5.9+dfsg-2_arm64.deb": "3974ddba57ed9bbfff10a144baae64d647adbb38ebce5fa122e4f0dd16b77866",
+    "libnspr4_4.29-1_arm64.deb": "f83f450a49499e320b1d7723a596be2414bf7adfd20315ba72df0e7735d98bc5",
+    "libnss3_3.61-1+deb11u2_arm64.deb": "c10ac0797a3c5f694ab86251d22d8d1452b03e50fc30999edd91a45bc202696d",
+    "libnuma1_2.0.12-1+b1_arm64.deb": "4eda519ae1f36f6376380fb2798ca0f50e104930845d8c51561ec455e98c57fc",
+    "libodbc1_2.3.6-0.1+b1_arm64.deb": "bd0060e4333b038300fb9f4a225adebbdd5054fb6298960eef36f52c50733bc8",
+    "libogdi4.1_4.1.0+ds-5_arm64.deb": "48903ccacb992d04131def3accceac424f6226aa4059201303131cf89eaeddbe",
+    "libogg0_1.3.4-0.1_arm64.deb": "910d1f3893a9340ea83bf19deebbc4e0d2362f22c274c2c2d3f00e4ba386c871",
+    "libopenal-data_1.19.1-2_all.deb": "695a650803f885459994bb921132d956c2b693759572005351a5b13773c754cd",
+    "libopenal1_1.19.1-2_arm64.deb": "848f7cb93823c780ab58c0da67535316ef797666934d06ed6d64e902d4e2df11",
+    "libopencore-amrnb0_0.1.5-1_arm64.deb": "85c1c3a54c4c85a4c630ef21b86ff1a8278b43613659299715e5b255a9e5614f",
+    "libopencore-amrwb0_0.1.5-1_arm64.deb": "a597315898b997ab702696608756a738701047d70275b681406c91b850a87625",
+    "libopencv-calib3d-dev_4.5.1+dfsg-5_arm64.deb": "9b32b570cb47735db6879a925956168e85155ef048d9895c7cbce014ef9b4529",
+    "libopencv-calib3d4.5_4.5.1+dfsg-5_arm64.deb": "189fbfc0fa850bf8ee4f3484c5a9a71d38bf1ba7694ebe0a218cf398a755f1d5",
+    "libopencv-contrib-dev_4.5.1+dfsg-5_arm64.deb": "36838790208c16db93236aee39bf77fee8ab8bff6ef4b35c22e9ebfd0d900099",
+    "libopencv-contrib4.5_4.5.1+dfsg-5_arm64.deb": "7d80388fc6ce9662a2706cd0371ec1b75b2a0473cc17536d6bb329c597317e65",
+    "libopencv-core-dev_4.5.1+dfsg-5_arm64.deb": "b8d8873d726345a0029f524dd7791b581a8379e1cd6e3aed6cc462b47c495fe0",
+    "libopencv-core4.5_4.5.1+dfsg-5_arm64.deb": "4736fc101e6fffd1f11f7dba48a1fc72aca5683cac123c25160718628a682e9f",
+    "libopencv-dev_4.5.1+dfsg-5_arm64.deb": "cca973f700a3177cfeb77bbdf0fbb34d49a894b93719b3e3fc13dea145ed9d6b",
+    "libopencv-dnn-dev_4.5.1+dfsg-5_arm64.deb": "e506228fc13a8533bec5a88b6b73cc931f31e0032218465dac81d2fb659d8988",
+    "libopencv-dnn4.5_4.5.1+dfsg-5_arm64.deb": "0c121b36ba1cd55c9355aa9f2dc42b78afe83a5ab3734e3a5b16ba68ae5ef7d1",
+    "libopencv-features2d-dev_4.5.1+dfsg-5_arm64.deb": "d9cc52691782a9e0714814f33ce177cfe56d78e2b6a828e920a0739286806ae3",
+    "libopencv-features2d4.5_4.5.1+dfsg-5_arm64.deb": "ac5c82fff13f36eea33fb92e04cfd7078642cca527382ce8cb2e5e7c75b1d698",
+    "libopencv-flann-dev_4.5.1+dfsg-5_arm64.deb": "ef70c57db440c2805be002d5638fb381727e9b0c9faf3462857565884eed81b9",
+    "libopencv-flann4.5_4.5.1+dfsg-5_arm64.deb": "20c490a68d367e4ac47b443850697757d97dc30e74ffd31b0025841f2829ad80",
+    "libopencv-highgui-dev_4.5.1+dfsg-5_arm64.deb": "27c41d0d726870b9245327857e6207657971b023d5fe251fd0a539ff84ce69ba",
+    "libopencv-highgui4.5_4.5.1+dfsg-5_arm64.deb": "5af44ec6da17dc8d000215ff9377a6eff00ab7970c078f3cd46492ceec1be7c8",
+    "libopencv-imgcodecs-dev_4.5.1+dfsg-5_arm64.deb": "27ec650759d661651dbfa9fe9d571b106048f0e6a7863c6fa8e9c224b6c64ad6",
+    "libopencv-imgcodecs4.5_4.5.1+dfsg-5_arm64.deb": "8d68e9a89517628082fb5d58d47d865c69c7e070bd91fcab8240d8f082e85e54",
+    "libopencv-imgproc-dev_4.5.1+dfsg-5_arm64.deb": "22fd1fd47d57f4085472653b420fcfd8d4180d85ccfb8b9ffaab7e110643fbe0",
+    "libopencv-imgproc4.5_4.5.1+dfsg-5_arm64.deb": "fcbf06a539696d53a1386a1609f51c0890a7d58a58fd67e153facd8e13728754",
+    "libopencv-ml-dev_4.5.1+dfsg-5_arm64.deb": "fb7022c93d9c4f4bc050d9f3ca545133d1d5a70efcc692ef7fc78f4d902fcf5c",
+    "libopencv-ml4.5_4.5.1+dfsg-5_arm64.deb": "b7eb23cc968b4409d044addcad4b534282fc208eb4958b811f4404eebb3c52a7",
+    "libopencv-objdetect-dev_4.5.1+dfsg-5_arm64.deb": "db41fa5f2a3eee924d2bb9cad42e8c416a66f87a498562c4399e6690176d61d0",
+    "libopencv-objdetect4.5_4.5.1+dfsg-5_arm64.deb": "9f3784842133a8ffc764a72572b8631049d8627ea8d7c120ced7e44f8a981641",
+    "libopencv-photo-dev_4.5.1+dfsg-5_arm64.deb": "13db446289d550a9dbf7214e49cbb46c895331c3a7fc7813594423b9f9d6bd3c",
+    "libopencv-photo4.5_4.5.1+dfsg-5_arm64.deb": "af684d483ab247c47941682ec6acd5d045438ccca8085c442973529da783cb4f",
+    "libopencv-shape-dev_4.5.1+dfsg-5_arm64.deb": "04313d5b4408784e50e314fcdf27002cba2c19c8b28d1ef3d4b3ea75d92ca303",
+    "libopencv-shape4.5_4.5.1+dfsg-5_arm64.deb": "b30cf313926d1064a676c857b2f57afba78e0a3942bdd0993b83eb17144b9a8d",
+    "libopencv-stitching-dev_4.5.1+dfsg-5_arm64.deb": "e0998b49adf404ff376c725bb6ad62663ef50bac4ec9bacebeda9fc19fe61dc8",
+    "libopencv-stitching4.5_4.5.1+dfsg-5_arm64.deb": "2316563a7b487d0b245f84e87eb0db61423f3f730c474a7776d3910ac1a1b210",
+    "libopencv-superres-dev_4.5.1+dfsg-5_arm64.deb": "f8524762200001fbe8acff2d2dd1e110ac37ed5e124837778d0acb703fdc9d22",
+    "libopencv-superres4.5_4.5.1+dfsg-5_arm64.deb": "1da58f51aa2ca2fe8a425a7f6f84ee5252c90fef10cfc90d2ccd2190ebaa8e43",
+    "libopencv-video-dev_4.5.1+dfsg-5_arm64.deb": "a37ea4ef728084858601f8a61b018e28e146951311dd55b4b75b83e4788b8f49",
+    "libopencv-video4.5_4.5.1+dfsg-5_arm64.deb": "c49598f7fe96b473c8a6c0e091a407a50f1b9514c398800497c0ae2691be3dc7",
+    "libopencv-videoio-dev_4.5.1+dfsg-5_arm64.deb": "60464425514a01b82dc4798d777d17cb9802119b05283cc4a44623a60bc98a48",
+    "libopencv-videoio4.5_4.5.1+dfsg-5_arm64.deb": "ab79662142f6aa93b54c30eb0f388da3445fc11fb56b7888825b9b6bde2a7536",
+    "libopencv-videostab-dev_4.5.1+dfsg-5_arm64.deb": "2c517c7d4394cd702e417c33b7fa5154ba650d2850ee2530dcc3b86943a471a7",
+    "libopencv-videostab4.5_4.5.1+dfsg-5_arm64.deb": "ce078bd6fe7da56efbdb4b03b7bde1db3fdf8923a70e99528e9eaf3a966e89b5",
+    "libopencv-viz-dev_4.5.1+dfsg-5_arm64.deb": "e0ca0f7422c742889831ee3a9836e6efa15beef70784e7a93f03187efd073d34",
+    "libopencv-viz4.5_4.5.1+dfsg-5_arm64.deb": "fb92c16c42a4faf7f3393f82428865929225a073894100f75c4535cf56e06f97",
+    "libopenexr-dev_2.5.4-2_arm64.deb": "fc0a9ffdda657e668ee164ffeebfbc27f9c5fb80556567f9c25bd1cbec05ff8d",
+    "libopenexr25_2.5.4-2_arm64.deb": "15bc59e1f8abf11d17e9b028a54b15f8f9b9448b6ea98175ddfb3acdd6f8ecd4",
+    "libopengl0_1.3.2-1_arm64.deb": "0dcd4846079fd8106f92f943331e4d035b3c79d9eae5a337135ced490a0deb15",
+    "libopenh264-6_2.2.0+dfsg-2~bpo11+1_arm64.deb": "9c2675bca36718ebb64f937a8d5a943056beefd8c77aa98890c9d56a7b99105d",
+    "libopenjp2-7_2.4.0-3_arm64.deb": "4fb3637093bbbde4499f1344b399c6eb61bbe51bdc3c40a09c5fcc1efec660cb",
+    "libopenmpt0_0.4.11-1_arm64.deb": "a78a20536f771b360f757999dc02e2c6c9033491afd5f7875d0561ec28caf19e",
+    "libopenni2-0_2.2.0.33+dfsg-15_arm64.deb": "be1312e6cbb242b8f9886d821df570ab831c50b6c8e68d39b8a7b8eb51ab4af3",
+    "libopus0_1.3.1-0.1_arm64.deb": "86d96e6e99820be150e4e1d335cf8503c5802a3ac47103ba25eebf77a0699a13",
+    "liborc-0.4-0_0.4.32-1_arm64.deb": "45948981ff4afa3890eca22edf709445088b301b593a3ad3eb5f8e524f661261",
+    "liborc-0.4-dev-bin_0.4.32-1_arm64.deb": "c857edaf37f9cc95bcbcb70665a182c4e65cb8e9fa164bca29e8cc3788e518b7",
+    "liborc-0.4-dev_0.4.32-1_arm64.deb": "3ecdc91537147154a7602e9923280f70ff5e4c6fb7f1c7a927c31d1af063ad8f",
+    "libp11-kit0_0.23.22-1_arm64.deb": "ac6e8eda3277708069bc6f03aff06dc319855d64ede9fca219938e52f92ee09c",
+    "libpango-1.0-0_1.46.2-3_arm64.deb": "6bbb5d942bf5075e07ba2290687cf03939e29dd89c67cba4d868a5d5ca94d360",
+    "libpangocairo-1.0-0_1.46.2-3_arm64.deb": "6947061235f6a3fce541b985ae38509298f7b46299e31fd985d7c596e31e4bbf",
+    "libpangoft2-1.0-0_1.46.2-3_arm64.deb": "75c9b7f28b80822b6e4edea5e2235257f877ac6cade7930c6683e24395e952ec",
+    "libpcre16-3_8.39-13_arm64.deb": "8c254c9f1962db4e8c38b077fce549e00f9201c25936f1b9c9ca36d6aa82e2f3",
+    "libpcre2-16-0_10.36-2_arm64.deb": "59f303e7e77e89c6a4ee906e79b312362bd8e4e6bbb0f3aaff881b3e5d0dc577",
+    "libpcre2-32-0_10.36-2_arm64.deb": "6e1695eb7c4947d74c257f55937aece65c7ac077c6f02fca98a88082d8d6d087",
+    "libpcre2-dev_10.36-2_arm64.deb": "059ecaad9508c57513ef1d298d39091fbd5d017e30e10a0702516ec8b02998ac",
+    "libpcre2-posix2_10.36-2_arm64.deb": "3fed2511147e36670758ad4853c2527340cd354e88de2b9f1797b74101f58e34",
+    "libpcre3-dev_8.39-13_arm64.deb": "fc10133538dd98895d466b2f273e5373e5e44cac832ed588c517cf3a795c5724",
+    "libpcre32-3_8.39-13_arm64.deb": "a5eeebe0a2d4106558c6c626b4297055a38bd67059b9a0afcf04c40602e4a6ab",
+    "libpcre3_8.39-13_arm64.deb": "21cac4064a41dbc354295c437f37bf623f9004513a97a6fa030248566aa986e9",
+    "libpcrecpp0v5_8.39-13_arm64.deb": "266be5873eda3f30867f26028636d11d6cf25e0147467bdcac2c65e4a90c4ffd",
+    "libpgm-5.3-0_5.3.128~dfsg-2_arm64.deb": "6a632aa13cafe154d6212a57710f058405dd895fb62d464e16961b28d7325cbb",
+    "libpixman-1-0_0.40.0-1_arm64.deb": "0be923132af8fa7102c09a3c8d200cd8475b633a9a5f1609f7ad653851fb6448",
+    "libpng-dev_1.6.37-3_arm64.deb": "15da2d4389f62ac5daf0f91f0a34db8007986ce77f079ea1f6f2ee92ea6a620d",
+    "libpng16-16_1.6.37-3_arm64.deb": "f5f61274aa5f71b9e44b077bd7b9fa9cd5ff71d8b8295f47dc1b2d45378aa73e",
+    "libpoppler102_20.09.0-3.1_arm64.deb": "cb9d93e535446d9662722614109a3d9c2df89dd970a473623f31895c37be1513",
+    "libpq5_13.5-0+deb11u1_arm64.deb": "84daa5d6407c51e5cab185d053c896c58a6035e05157adb197d077f2d417f7af",
+    "libproj19_7.2.1-1_arm64.deb": "535a698960d6fe73de45099fa289b7e9382319b8ea3ab3ec535db52f893e7af2",
+    "libprotobuf23_3.12.4-1_arm64.deb": "f3935bf86962ef3df68aca17c9f1fa0a55a9a0c74a78a225c2dbf78ed5746cfa",
+    "libproxy1v5_0.4.17-1_arm64.deb": "b81ca7f47e384ed7117a75cfe9798bd11d0085b1b5edce4f9ffcf4e678e24b71",
+    "libpsl-dev_0.21.0-1.2_arm64.deb": "b5aac74d63fae3f6a4e835f3f4cea23f62efb4bb32421fb4fee9eb2d57b1da8c",
+    "libpsl5_0.21.0-1.2_arm64.deb": "12637647316e770c37a4bfec7aef27ed472f2850b5f59dd508505dda32519584",
+    "libpthread-stubs0-dev_0.4-1_arm64.deb": "acd58ed5d26d3f4d4b0856ebec6bc43f9c4357601a532eee0d2de839a8b8952e",
+    "libpulse0_14.2-2_arm64.deb": "bb6533d2f67cd7fb94bf2ae1d7f13ae6b3c5b70c098038f21bc47fce30c88621",
+    "libqhull8.0_2020.2-3_arm64.deb": "e42e31c799c6017158dcc6b5fce9ccc68550b54255df50f52c947a34f2a63943",
+    "libqrencode4_4.1.1-1_arm64.deb": "57cb902bf90c5d939ff6b72d7beb821c8be0d13be11c8eea3341005fdeccd7cf",
+    "librabbitmq4_0.10.0-1_arm64.deb": "9460d0c3c016883bd5bfb5e66a47cae445f93e2e6f43c1c951738ab51d2ec982",
+    "libraw1394-11_2.1.2-2_arm64.deb": "81a1e9bd2b790aa7ce7c426dd1742d3310894b01f124bc41962331b834da6cc3",
+    "libraw1394-dev_2.1.2-2_arm64.deb": "84d7280c5e0d38a77c7d8ccc6d5d2986b42bd64245533947aa9c684077fa7243",
+    "libreadline8_8.1-1_arm64.deb": "500c3cdc00dcaea2c4ed736e00bfcb6cb43c3415e808566c5dfa266dbfc0c5e5",
+    "librest-0.7-0_0.8.1-1.1_arm64.deb": "c1b636d7a66996743d248cb9e6042167b03b442150d39b349b12348a31690ee0",
+    "librsvg2-2_2.50.3+dfsg-1_arm64.deb": "79688f922da4c45e546c77667f1ea9480e3b96dd65e8eef88bcb44ef335cd6bd",
+    "librtmp1_2.4+20151223.gitfa8646d.1-2+b2_arm64.deb": "a3a1a6e4b02bcd3254e932b1972ed744082fd7dd5cc1545eec3dd3d539ce6c93",
+    "librttopo1_1.1.0-2_arm64.deb": "f20685ed048635be16e8abf790e14d7e88bb4e2335d371dff631b4adbdebc6a8",
+    "libsamplerate0_0.2.1+ds0-1_arm64.deb": "2217f60d0e8e10b966811328a50bd6ac4c33ec32c80d9fd92d699a2185dcb629",
+    "libsasl2-2_2.1.27+dfsg-2.1+deb11u1_arm64.deb": "fc4c943224b8fb6aaa86439ff60dcec4ca1aeb4730f121e594c68a37b3e0c88f",
+    "libsasl2-modules-db_2.1.27+dfsg-2.1+deb11u1_arm64.deb": "006239b28681f507db0937125a13810c8cf03e3fffe9b7c8433445af86805d12",
+    "libsbc1_1.5-3_arm64.deb": "42da4d0df79a713822a71abf87e29a7fd56650870e68ee0242db4d78bce8eefb",
+    "libsdl2-2.0-0_2.0.14+dfsg2-3_arm64.deb": "84044621db62626a6e57c0def89db5efb9a5ebda0eec6fa68a2c90e79a7d46c2",
+    "libselinux1-dev_3.1-3_arm64.deb": "91e9c58f4a33e44ea0543d2e2d9e259d6833fbfa13704bcff685ed6a3d7c8eec",
+    "libsensors-config_3.6.0-7_all.deb": "4265811140a591d27c99d026b63707d8235d98c73d7543c66ab9ec73c28523fc",
+    "libsensors5_3.6.0-7_arm64.deb": "fd5533c6293d881d67e488ad0549c0b0351e1b770037a08018e5e88996cb95dc",
+    "libsepol1-dev_3.1-1_arm64.deb": "2b01df0d3a8b1d94a9a4cb925219d7b156ae9e089c2dc07791af6170c7bd44cf",
+    "libsepol1_3.1-1_arm64.deb": "354d36c3084c14f242baba3a06372a3c034cec7a0cb38e626fc03cc4751b2cd3",
+    "libserd-0-0_0.30.10-2_arm64.deb": "d0090cf9f8855b5af6f18758933fb2ae2348d8ca383745510638f6a4cbb3a898",
+    "libshine3_3.1.1-2_arm64.deb": "d64982ddfbdfcef714dc35a760a752ab1f3739aaee8011bc5c3f03afa73f465f",
+    "libshout3_2.4.5-1+b1_arm64.deb": "6b4a6d87737d98ccfbe2b392fed75b3bc492932b7f345ffb8613a79a9f8db367",
+    "libsidplay1v5_1.36.60-1_arm64.deb": "6ed3b3a8903b75bf22ac40d3fcaf0f7a476592913fba38db9ebf0b0d4ce7c328",
+    "libslang2_2.3.2-5_arm64.deb": "61c51c2ff17b38a0791193460df9a09a5f5a90ece01483202d0667059814503f",
+    "libsnappy1v5_1.1.8-1_arm64.deb": "48cb00030ca2e87780f815e6b5e354c76642c6de5c7a287a18d70b24880c70d1",
+    "libsndfile1_1.0.31-2_arm64.deb": "35cd1ede25dda91abdfd23bc02fbfe9afc72e2a11178bebcc5ef76601a2a60b7",
+    "libsndio7.0_1.5.0-3_arm64.deb": "5d3fcdcde0de0021ee217769e0866dcd524734a04f961c2ecc33488db47ba545",
+    "libsocket++1_1.12.13-11_arm64.deb": "ea74ce1260340fedc20131f4f8183c5ee55fdc4e153c2850bceb0fc7173f4de3",
+    "libsodium23_1.0.18-1_arm64.deb": "f00a5c6ccaeb6a70bc07c7a56d61c605281c2b1cbea29611b69dfc789274db0c",
+    "libsord-0-0_0.16.8-2_arm64.deb": "af1aa4057c185c1f7b07d14d1b2711cadd572bbc4dc17ce1f1144180974e83c1",
+    "libsoundtouch1_2.2+ds1-2_arm64.deb": "c44e330c7f54de52a0fa695374536d24a093ff34116c250002066de84570019a",
+    "libsoup-gnome2.4-1_2.72.0-2_arm64.deb": "7e0aacd0e2e484844b86fce2dcaf842ff95f209ad353c52d685ed1b2bc346eb2",
+    "libsoup2.4-1_2.72.0-2_arm64.deb": "c11fd27b2cd0639d642d1b852c6e89f94742228d5a866d1e32f122bdb2b324d1",
+    "libsoup2.4-dev_2.72.0-2_arm64.deb": "f11b45fde07c3f94a756287dfc5d24850ef8ca02c84ced03bd81145c90307195",
+    "libsoxr0_0.1.3-4_arm64.deb": "8f1b1780a5ced7a0821a8040d0f3ab5815acd5d2f38b12cca915a9a9d0ee28b7",
+    "libspandsp2_0.0.6+dfsg-2_arm64.deb": "6c58a18a6a4e9469e677f3dfe256a481db7d2909c16f4ebc4d2d0dd3f869d191",
+    "libspatialite7_5.0.1-2_arm64.deb": "0268c4e54141c222e6ae6984f1c402f78a806e0e70e411235524445b0e2beb2a",
+    "libspeex1_1.2~rc1.2-1.1_arm64.deb": "5bdef83a0a8f0afda640f0166a64f9160c459faa0c2681f9cef7a96933733340",
+    "libsqlite3-0_3.34.1-3_arm64.deb": "1e33cd39dc4fff2a7edd7bb7e90a71e20fb528f6a581fe0287652e4dae77e0d0",
+    "libsqlite3-dev_3.34.1-3_arm64.deb": "02245250f77ea400f0de1532248b8696c8ddb282e1fbba17f1b5410f823624ee",
+    "libsratom-0-0_0.6.8-1_arm64.deb": "32fd27b9233db0895f6da92db5d3d58dbdde0f6d3e58e49683553e4fae46dc41",
+    "libsrt1.4-gnutls_1.4.2-1.3_arm64.deb": "08a94b07becea150a1385614fb7b4c1b09f864db5ab8185b586d099ffdf11b8a",
+    "libsrtp2-1_2.3.0-5_arm64.deb": "0b3195777f70d1a1c9bccb7d2a6bcf6075043ba1d4bdb5d9800946bb49e84b1e",
+    "libssh-gcrypt-4_0.9.5-1+deb11u1_arm64.deb": "ab5a221194b84dbbb75961555efd98eca8d84d568a15dd971a8c5579c0c4d9dd",
+    "libssh2-1_1.9.0-2_arm64.deb": "c3847ce093a395c4425f23c0a1601516248e2d241bedaab94ecd9686536214a7",
+    "libstdc++6_10.2.1-6_arm64.deb": "7869aa540cc46e9f3d4267d5bde2af0e5b429a820c1d6f1a4cfccfe788c31890",
+    "libsuperlu5_5.2.2+dfsg1-2_arm64.deb": "28d7257ec368508de05df08d87bdf1a535469758744e20ed93fc7c401b2740b9",
+    "libswresample-dev_4.3.3-0+deb11u1_arm64.deb": "790d775017119434a6eddbb68b85e29392119aaae5ed52bbe7a2734a45cb0b64",
+    "libswresample3_4.3.3-0+deb11u1_arm64.deb": "58ae7a8c97a8763ef3e3352915f65b9bb2bbfa1c977042fb7761a89c2f1f1e93",
+    "libswscale-dev_4.3.3-0+deb11u1_arm64.deb": "bbf45093f7ca81b3b3f3cfdcac5c01546e0ae5e7f99029361ab1b78672917c73",
+    "libswscale5_4.3.3-0+deb11u1_arm64.deb": "e29e8d8a7e4f1ad8f71e1c0b05859e1fe6840cbe36a3955aaf8536b587dfd028",
+    "libsystemd0_247.3-7_arm64.deb": "365b1d9bc9933d8cdcf8ca2d68e8751719e43c4b2a93a5cfce5ebb124f02decb",
+    "libsz2_1.0.4-1_arm64.deb": "8ed09313ff4408291fd0e3942b4129280babf882f2d3fe8ba48aac4be6def051",
+    "libtag1v5-vanilla_1.11.1+dfsg.1-3_arm64.deb": "5258f2fc45789d1f057e5a4adfff0ee07e1079c8435bf9e38e224e50ac8be45d",
+    "libtag1v5_1.11.1+dfsg.1-3_arm64.deb": "a19a754738f4880143e1fa38aa4540fc7bcca77041da77056b8ee79c63cc9be9",
+    "libtasn1-6_4.16.0-2_arm64.deb": "a89b659a3cf2d040885a7d00f3c547b6e362cdfeb5f89d0c777495d82a58e64f",
+    "libtbb-dev_2020.3-1_arm64.deb": "85bc6b8697aac9f2c481589de3471ca44402c383b3738304fc325ea8ec776b14",
+    "libtbb2_2020.3-1_arm64.deb": "c69b242838b3829c16b9580fa218387f0f0f7f976062df8a66c7d9c0a6e95a9e",
+    "libtcl8.6_8.6.11+dfsg-1_arm64.deb": "39047359624bb8229a0e26291ad56012ae6ad17e443e73dd9f38635102c9a0e4",
+    "libtesseract4_4.1.1-2.1_arm64.deb": "762932cc1bc533cf6d1f6ad08c108fb1f5f13131cc4c5a37ce777e5715fb56a0",
+    "libthai-data_0.1.28-3_all.deb": "64750cb822e54627a25b5a00cde06e233b5dea28571690215f672af97937f01b",
+    "libthai0_0.1.28-3_arm64.deb": "e7ac0d861936385cca0ea7e3b9b04d20e85a7dfbfaa801e093d9f7fcbcf841f6",
+    "libtheora0_1.1.1+dfsg.1-15_arm64.deb": "e1ca65eaa5c90af2f88a5ba157e4b61b38b3cdf7ca8b83f20db4ee2dc271c344",
+    "libtiff-dev_4.2.0-1+deb11u1_arm64.deb": "7a399d4215c787f8f78abec0d96822559a16d33d73750d588079c7445da02bef",
+    "libtiff5_4.2.0-1+deb11u1_arm64.deb": "fdb29f5dcae827ef3485c4395f2937e8880e3022fb72757965888e83bb096b6f",
+    "libtiffxx5_4.2.0-1+deb11u1_arm64.deb": "5126597feca5b7f97699c1f38596be99b9db7422c6c521b8270d5a0389606654",
+    "libtinfo6_6.2+20201114-2_arm64.deb": "21c0c33e00d091d0f326a083a77531270b8c56468500f0948d149f3e20b95385",
+    "libtk8.6_8.6.11-2_arm64.deb": "c189bdef93e4caebd58f952e99dfd1922ca182996fd4d0b4b33fb5fa5828dfa8",
+    "libtwolame0_0.4.0-2_arm64.deb": "73780c555796569a252ec5cf1ea919e59ef4031298bc4be1516a6a0e83f06b5a",
+    "libudev1_247.3-7_arm64.deb": "4c5d5b6736499d39eb87bf135f9bb6bc2051d945eb52644bbf52a26f7f8e6504",
+    "libudfread0_1.1.1-1_arm64.deb": "a54c888952f0eab05024e26a09cef78182144f7f11763af5d24c3947a8002648",
+    "libunistring2_0.9.10-4_arm64.deb": "53ff395ea4d8cf17c52155a452a0dc15af0ee2fa5cb3b0085b9c7335de8d5f7f",
+    "libunwind-dev_1.3.2-2_arm64.deb": "1256cc79e6614668240886eba0dfbc65ffe159a08b420dc2c515237891ab60a9",
+    "libunwind8_1.3.2-2_arm64.deb": "2a93283482cd89b6e6d3e1ee16497c911d6aacdc7414b9d24ca6851e221cf66c",
+    "liburiparser1_0.9.4+dfsg-1+deb11u1_arm64.deb": "4a184076b07eb3f6a409db354b651b5c024e3c783e35702038782c4300dbd037",
+    "libusb-1.0-0_1.0.24-3_arm64.deb": "61ca0a0412c4182cb007f4e447608857cd4c70ddbe730ecda15a495de7d2178f",
+    "libuuid1_2.36.1-8+deb11u1_arm64.deb": "3d677da6a22e9cac519fed5a2ed5b20a4217f51ca420fce57434b5e813c26e03",
+    "libv4l-0_1.20.0-2_arm64.deb": "d56810fc6ac3877da7731681e90fc1dd24d8288ba4ea0f29ff2751c0aa248e34",
+    "libv4lconvert0_1.20.0-2_arm64.deb": "d2da0adaf32562e9733561a67d06ba5d6ecb8a099033c4a3cdb257cc5b205e76",
+    "libva-drm2_2.10.0-1_arm64.deb": "45bf4248d72ce42940ee658bbba3025db0a233587bc49d773b1e3e9606d613a3",
+    "libva-x11-2_2.10.0-1_arm64.deb": "d6a845c9456a8b22366a25cbcd68a4ced425243a924e4b0048dc82f8b1f8853c",
+    "libva2_2.10.0-1_arm64.deb": "6dbb204d43bcaed495719fc6a793dcbce77f4ab12bc0ea4617ae4e816139d5a1",
+    "libvdpau1_1.4-3_arm64.deb": "9f44679cee3e9ed99525b2becff5b0ef040736b1a450e68fd3e2e536de52b99a",
+    "libvisual-0.4-0_0.4.0-17_arm64.deb": "1173621505fdc74b88210c7fffec97a7ffbbdc76b85f2392edeff3e6e7b114d0",
+    "libvo-aacenc0_0.1.3-2_arm64.deb": "b86d13dae80e35813d01492f4056aa924b08b41698468ab1d17425860f3d0151",
+    "libvo-amrwbenc0_0.1.3-2_arm64.deb": "9f359ac83bf72104f29584f0c9efd5c440a592f5d6ad24fb785213718084f624",
+    "libvorbis0a_1.3.7-1_arm64.deb": "2f902ae456bcada7b0d494d7bd7c994feb81c4158209d8a12c0b2d9e255edda7",
+    "libvorbisenc2_1.3.7-1_arm64.deb": "f1089e220c81e267caec859bf2e440bb78ed9f318bbb51cfd6c85d35bf80144b",
+    "libvorbisfile3_1.3.7-1_arm64.deb": "f8f418e15f99905d4a2d532617511a11d700e814f8ead1a883deea2f7241970c",
+    "libvpx6_1.9.0-1_arm64.deb": "878f04bcd1089f8f2aa47d20b7ec4922877e31e562c90f613756d5452b3814fd",
+    "libvtk9_9.0.1+dfsg1-8_arm64.deb": "3271f972b20a26fed4781466dbaff083833c30208ac7b71376d96dec2a402aa2",
+    "libvulkan1_1.2.162.0-1_arm64.deb": "303d48229ccab57342ad9cc36174429ee7b8b0cdb6e6e292b87ce3415fe5d65a",
+    "libwavpack1_5.4.0-1_arm64.deb": "81317be561d0cdb1239225772a8a9260d8178634a41263f072c340448c029490",
+    "libwayland-bin_1.18.0-2~exp1.1_arm64.deb": "79a850a284b308d14d5031c6e78ec566f1ab4437bde889140f96333d96cb0674",
+    "libwayland-client0_1.18.0-2~exp1.1_arm64.deb": "7bde74828c3508b5b81400c4b9ef51d65b566d7645747b777ec171eb8ecfce47",
+    "libwayland-cursor0_1.18.0-2~exp1.1_arm64.deb": "1c201b449abf41e864dd48c960c9ef7f180b5164a3e7562ae5fd467d60fd074e",
+    "libwayland-dev_1.18.0-2~exp1.1_arm64.deb": "2357033bfe3cee735220abb527ca0707a31dc2813defe7e67d738882607ecdb9",
+    "libwayland-egl1_1.18.0-2~exp1.1_arm64.deb": "8b5e2d8975330f308c226e3b51624a76ea8ebe5115dd8e929e05ea23c4169008",
+    "libwayland-server0_1.18.0-2~exp1.1_arm64.deb": "3bbcb9e41159b6268b40ce16b1512e5bcf38e63b8bcf2426eaa54b19c6988257",
+    "libwebp6_0.6.1-2.1_arm64.deb": "c4e7e63f283aaa9913ac78b9871434f543f87ff4641a9a1737e86a0b32a679a7",
+    "libwebpmux3_0.6.1-2.1_arm64.deb": "bf59f5c2e958af997f9754f78de0ed48178b4c33688c354b52ffdcb970876ca8",
+    "libwebrtc-audio-processing1_0.3-1+b1_arm64.deb": "f074066f53da5141ed8b5a221b7a38344f43504f13cda4597ac589e8bca914e9",
+    "libwildmidi2_0.4.3-1_arm64.deb": "09f041820a0e2e5e19ef541a7dc88521067c266561e6f7fa24accb5dcaefafc8",
+    "libwrap0_7.6.q-31_arm64.deb": "8e57d2f27eea81a61ea144e8c0b8301c3ab4a6195dc2366c2c703d49b7b79e7d",
+    "libx11-6_1.7.2-1_arm64.deb": "8872962f2a0a6b9e16cafc6acd2be56cee4ec7a16c2a0abdb9fcda6d0b31be3b",
+    "libx11-data_1.7.2-1_all.deb": "049b7eabced516acfdf44a5e81c26d108b16e4987e5d7604ea53eaade74027fb",
+    "libx11-dev_1.7.2-1_arm64.deb": "be35e106b9dc900b6a2e84fdb346c3a53a8440153a5e1708f0a9af473b31b0de",
+    "libx11-xcb-dev_1.7.2-1_arm64.deb": "20d59a5c097ffaf7cc206d017f8c3364ce5b0f8db39db13e2c57fcc01abe0eff",
+    "libx11-xcb1_1.7.2-1_arm64.deb": "4714e973f35a3fa8e4687ec86d9239bead13ebdc3990173d5520afa7504ab65d",
+    "libx264-160_0.160.3011+gitcde9a93-2.1_arm64.deb": "3e379d7147e548a43f8a4ca4fb291d839d0a3d8cc07df73e5cbc88b856818b92",
+    "libx265-192_3.4-2_arm64.deb": "4da85b00f95645ab01832af0bec627534608481a6f181c0fbbabeb5c04c2a1cc",
+    "libxau-dev_1.0.9-1_arm64.deb": "21db3761a8f388fc83707c00fac645d4332737a859dd727571e1e6ede003b048",
+    "libxau6_1.0.9-1_arm64.deb": "36c2bf400641a80521093771dc2562c903df4065f9eb03add50d90564337ea6c",
+    "libxcb-dri2-0_1.14-3_arm64.deb": "b99d1f4909d0a3fe85dfba6524fb0a8c4d08703366ed99f034417684e91ded5b",
+    "libxcb-dri3-0_1.14-3_arm64.deb": "9a6dc75fd8e9fe720f62f99cfebef0cbe51cf2909aa5e777254cb6a3ddf47f6f",
+    "libxcb-glx0_1.14-3_arm64.deb": "754902f3399fd5c9c851dbf150306f537acab7152b9f32206a7910b7c3f353e1",
+    "libxcb-present0_1.14-3_arm64.deb": "9e84b49e46833fd3fb366b04d19c652a0e8d2ebe3d40f19f9b530763ba2f7b88",
+    "libxcb-render0_1.14-3_arm64.deb": "e794ba2657c5f21dcca327343b41b1997a150b6ac27977970404d60f471be48a",
+    "libxcb-shm0_1.14-3_arm64.deb": "e7f59fc41744fe6b8b9ba97b262a051621173689e2a3e5ebb26dc253c9bdc48b",
+    "libxcb-sync1_1.14-3_arm64.deb": "ba70a2194fa7875f1a3ef6fb31bdd4cca5ca970926e3201994a166c5026ce442",
+    "libxcb-xfixes0_1.14-3_arm64.deb": "8185fca98fda89fc5a020b9a8cd92b093929830a29cf92e6a1eba04bd88bcf5f",
+    "libxcb1-dev_1.14-3_arm64.deb": "43ebe78dd7f66933286fe68fd7ccc650ef14464d479fff13e635e95d1f742efa",
+    "libxcb1_1.14-3_arm64.deb": "48f82b65c93adb7af7757961fdd2730928316459f008d767b7104a56bc20a8f1",
+    "libxcomposite1_0.4.5-1_arm64.deb": "cfe39326fdb822e9d060ed5eb3f95b14459dd6b73793c5290000f9b27f8bad37",
+    "libxcursor1_1.2.0-2_arm64.deb": "2e309833ccf7e6b62560240cd84e325cafcb2ce70b1fb297469957360cee4478",
+    "libxdamage1_1.1.5-2_arm64.deb": "696cb56f414e7c0ea9a3bcbcb63b07f6ed8e980023c1b35006d5c1dc0d0213ed",
+    "libxdmcp-dev_1.1.2-3_arm64.deb": "6fd0bc51f3a4e6b7f944f24f15524a4c4ba68a4b0aa136c18bdb96a2d36988f2",
+    "libxdmcp6_1.1.2-3_arm64.deb": "e92569ac33247261aa09adfadc34ced3994ac301cf8b58de415a2d5dbf15ccfc",
+    "libxerces-c3.2_3.2.3+debian-3_arm64.deb": "59311a05cc1d2c693840db899c02c0e8d1ba2e9e66961e8284053255d4c38866",
+    "libxext6_1.3.3-1.1_arm64.deb": "57237ecf54662372e206b154c0ab6096e05955e048552575b45d3ad14a6ff6e5",
+    "libxfixes3_5.0.3-2_arm64.deb": "eb70f12af1d13e1632ee29ddf103617af00a078faf6c3a2531ab3d01b395606b",
+    "libxft2_2.3.2-2_arm64.deb": "6941176bcc78bf02d1635575a8cc726a7eb0628d8476efca7607718bdc1f50c5",
+    "libxi6_1.7.10-1_arm64.deb": "0a6788844441f160d970fc7d61004607fe92cfad8966d0b371291703201b3971",
+    "libxinerama1_1.1.4-2_arm64.deb": "bbdef95d025fb804797a5b1a71f319f5f74c0114e90d759b3e9ecf7654442598",
+    "libxkbcommon0_1.0.3-2_arm64.deb": "91c19f642af34ae8cb909d00d08bc83f0b4f8e87ddde6984bd8bff0f7bf83204",
+    "libxml2-dev_2.9.10+dfsg-6.7+deb11u1_arm64.deb": "1532024cfe6074d16c558dfbafdd669cc1517e21a5268e130b401f0c409355a4",
+    "libxml2_2.9.10+dfsg-6.7+deb11u1_arm64.deb": "8a1bae68267cc508cd13662f5fd37f9b445e199b21a3931e3f20be8540495950",
+    "libxpm4_3.5.12-1_arm64.deb": "48ae9f8f91e36956e25bf724fc0fb815ce6202ca610570bd6eb5a077f3580b5a",
+    "libxrandr2_1.5.1-1_arm64.deb": "04c9c59ba1e9648e0ec80d66fa34bab7bf039822f32eb31f706656968052e915",
+    "libxrender1_0.9.10-1_arm64.deb": "fcae69900b599e7b31b31eafa203a184e00376ade1d2f74f9b3d7b24991573a0",
+    "libxshmfence1_1.3-1_arm64.deb": "fa2edaae6902681ecd02534dcdf8389ac48714d3385d572cc17747160957acc8",
+    "libxss1_1.2.3-1_arm64.deb": "e0ff80e309eacda5face68b9a3bd56718fed2750af429324c35d7c9491c335f4",
+    "libxvidcore4_1.3.7-1_arm64.deb": "b950edcb42803f158f94cd2ee44850082c98c92d54e20982ad933936f5f1d181",
+    "libxxf86vm1_1.1.4-1+b2_arm64.deb": "8a4826772ac480804d6b8d776a4130d95260c036b9b218de4c8a0f07eb9c5bba",
+    "libz3-4_4.8.10-1_arm64.deb": "ae1ea58ecfdd4b5ec53d734e60ac2df37fddb11888b7730a19335f1a9b09f489",
+    "libzbar0_0.23.90-1_arm64.deb": "954f155683b38978edeb674e1492dbcb1c8987adf23a72f1987074dd6fa25004",
+    "libzmq5_4.3.4-1_arm64.deb": "e5eaecc454d6792848a2ff866d73e3123b9ccdd08c9bd9e6096b52f08e484a13",
+    "libzstd1_1.4.8+dfsg-2.1_arm64.deb": "dd01659c6c122f983a3369a04ede63539f666585d52a03f8aa2c27b307e547e0",
+    "libzvbi-common_0.2.35-18_all.deb": "53ed21370b937a9385e1fcf1626400891bd4fd86a76b31654fb45e0875d8bfb8",
+    "libzvbi0_0.2.35-18_arm64.deb": "40626984d48d486b62f08c255eb9397a04f52ca2983e8d689e5de5e94e29a4b1",
+    "libzxingcore1_1.1.1-2_arm64.deb": "c88bc936cb0ac8bde1bfdae8e9bc1d1e0c8f2e93454245bc884f9b81c49e7246",
+    "lsb-base_11.1.0_all.deb": "89ed6332074d827a65305f9a51e591dff20641d61ff5e11f4e1822a9987e96fe",
+    "mariadb-common_10.5.15-0+deb11u1_all.deb": "a98b12228a79f29c588cb621f0fee395b263fcfc5037b912a22e8b168be3550d",
+    "mysql-common_5.8+1.0.7_all.deb": "22b3130e002c2c2fa6a1124aaccbe3a6ddbbb4d6bf03beed8a6f044027dcb720",
+    "ocl-icd-libopencl1_2.2.14-2_arm64.deb": "988af69eca9c4b7433572d11ecbc048a7680ae15afa78941782945b18ff185d7",
+    "odbcinst1debian2_2.3.6-0.1+b1_arm64.deb": "3b22a944687b3007a3484673a68e2a4483fd9237530b0ec359e423c8a745ca0e",
+    "odbcinst_2.3.6-0.1+b1_arm64.deb": "c0a9b4ade83bc9a28967e1e981cd1c93f9e6654cf6d53f1fa86db84b3bb8ad89",
+    "perl_5.32.1-4+deb11u2_arm64.deb": "625a2d0cafb5089953012d60d3a5ba726b692d9d49955a251b78b8cce884d05b",
+    "pkg-config_0.29.2-1_arm64.deb": "074d64f7a6bb5fb9139661aea20815438d8ffe8d7bb44b7c3f58e220c153fdbd",
+    "proj-data_7.2.1-1_all.deb": "40c64f7808d8233c08f3aa2745211e705828b4ae6fc5dbd62a934d8c3e9fd6e5",
+    "python3-distutils_3.9.2-1_all.deb": "05ec4080e0f05ba6b1c339d89c97f6343919be450b66cf4cfb215f54dcb85e58",
+    "python3-lib2to3_3.9.2-1_all.deb": "802c198e5dd0b5af85a6937e426a85d616680785e8d18148fac451281a83a9a9",
+    "python3_3.9.2-3_arm64.deb": "79197285d25e73a2a07667efe80af152dd932ac5ef3e13717f1ac824d111ea81",
+    "readline-common_8.1-1_all.deb": "3f947176ef949f93e4ad5d76c067d33fa97cf90b62ee0748acb4f5f64790edc8",
+    "sensible-utils_0.0.14_all.deb": "b9a447dc4ec8714196b037e20a2209e62cd669f5450222952f259bda4416b71f",
+    "shared-mime-info_2.0-1_arm64.deb": "33257bc679bee7b2627a001eb747f3378ea8c8063863d2cb6edb6ad7f37f280a",
+    "timgm6mb-soundfont_1.3-5_all.deb": "034abdfb296d9353433513dad5dbdcab46425ee6008fc02fe7039b46e75edc54",
+    "ttf-bitstream-vera_1.10-8.1_all.deb": "ba622edf73744b2951bbd20bfc113a1a875a9b0c6fed1ac9e9c7f4b54dd8a048",
+    "tzdata_2021a-1+deb11u3_all.deb": "61346a9f8cda14c34251d2440c8de8dab7c09bda7ebb96533166b4567359de66",
+    "ucf_3.0043_all.deb": "ebef6bcd777b5c0cc2699926f2159db08433aed07c50cb321fd828b28c5e8d53",
+    "uuid-dev_2.36.1-8+deb11u1_arm64.deb": "efbc2d26a728bb6212b52bf9c1faa7ee51159068072e2db0a383919ded7f308f",
+    "x11-common_7.7+22_all.deb": "5d1c3287826f60c3a82158b803b9c0489b8aad845ca23a53a982eba3dbb82aa3",
+    "x11proto-core-dev_2020.1-1_all.deb": "92941b1b2a7889a67e952a9301339202b6b390b77af939a26ee15c94ef4fad7e",
+    "x11proto-dev_2020.1-1_all.deb": "d5568d587d9ad2664c34c14b0ac538ccb3c567e126ee5291085a8de704a565f5",
+    "xkb-data_2.29-2_all.deb": "9122cccc67e6b3c3aef2fa9c50ef9d793a12f951c76698a02b1f4ceb9e3634e5",
+    "xorg-sgml-doctools_1.11-1.1_all.deb": "168345058319094e475a87ace66f5fb6ae802109650ea8434d672117982b5d0a",
+    "xtrans-dev_1.4.0-1_all.deb": "9ce1af9464faee0c679348dd11cdf63934c12e734a64e0903692b0cb5af38e06",
+    "zlib1g-dev_1.2.11.dfsg-2_arm64.deb": "1e6ed652eebd3761454d75db5459c247cd5d29e58bbe9f6b4b62a62d96f7c279",
+}
diff --git a/debian/gstreamer_backport_notes.txt b/debian/gstreamer_backport_notes.txt
new file mode 100644
index 0000000..c543a0f
--- /dev/null
+++ b/debian/gstreamer_backport_notes.txt
@@ -0,0 +1,67 @@
+Some notes on backporting gstreamer 1.20 from testing (bookworm) to bullseye
+
+Create chroot build environment. This is kept clean - each build step uses this as a base image and overlays files on top of it.
+    sudo sbuild-createchroot --extra-repository="deb http://deb.debian.org/debian bullseye-backports main" --chroot-prefix=bullseye-backports bullseye /srv/chroot/bullseye-backports-${ARCH} http://deb.debian.org/debian
+
+Download sources for each library. I worked out of a directory "$HOME/backports"
+dget -x ...
+    http://deb.debian.org/debian/pool/main/g/gstreamer1.0/gstreamer1.0_1.20.1-1.dsc
+    http://deb.debian.org/debian/pool/main/g/gst-plugins-base1.0/gst-plugins-base1.0_1.20.1-1.dsc
+    http://deb.debian.org/debian/pool/main/g/gst-plugins-good1.0/gst-plugins-good1.0_1.20.1-1.dsc
+    http://deb.debian.org/debian/pool/main/g/gst-plugins-ugly1.0/gst-plugins-ugly1.0_1.20.1-1.dsc
+
+    http://deb.debian.org/debian/pool/main/libn/libnice/libnice_0.1.18-2.dsc
+    http://deb.debian.org/debian/pool/main/o/openh264/openh264_2.2.0+dfsg-2.dsc
+    http://deb.debian.org/debian/pool/main/libf/libfreeaptx/libfreeaptx_0.1.1-1.dsc
+
+    http://deb.debian.org/debian/pool/main/g/gst-plugins-bad1.0/gst-plugins-bad1.0_1.20.1-1.dsc
+
+
+Enter each directory of sources, modify with `dch --bpo`. Use default. This will append '~bpo' which in the debian version string is the "type" of the package. This is by convention and ensures correct version resolution if these packages are upgraded in the future.
+
+Build the packages in this order to resolve dependencies between them. I found this minimal set could be built against bullseye directly - the only dependencies with unmet versions in bullseye are libnice, libopenh264, and libfreeaptx, so we backport those as well.
+
+For each package we append set --debbuildopts="-v<version number>". Version number should be the previous release that found in bullseye. This generates the proper changelog between that version and our backport's version. sbuild will automatically resolve all dependencies possible with apt. For dependencies between our backports we specify --extra-package. We could setup an apt repo as we do in the last step but it's probably not worth the effort. I'd also replace ${HOME} with the absolute path - not sure when exactly this is resolved.
+
+
+
+gstreamer1.0
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v1.18.4-2"
+
+gst-plugins-base
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v1.18.4-2" --extra-package=${HOME}backports/libgstreamer1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_${ARCH}.deb
+
+gst-plugins-good
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v1.18.4-2" --extra-package=${HOME}backports/libgstreamer1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-gl1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-gl_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gst-plugins-base-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_${ARCH}.deb
+
+gst-plugins-ugly
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v1.18.4-2" --extra-package=${HOME}backports/libgstreamer1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-gl1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-gl_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gst-plugins-base-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-good_1.20.1-1~bpo11+1_${ARCH}.deb
+
+libnice
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v0.1.16-1"
+
+openh264
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v0"
+
+libfreeaptx
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v0"
+
+# The opencv headers shipped with debian bullseye are broken - they require tracking.private.hpp. Copy this file into the chroot to help it out. It can be found in the opencv git repo (may be called tracking.detail.hpp).
+
+gst-plugins-bad
+    sbuild --arch=${ARCH} -d bullseye-backports --build-dep-resolver=aptitude --debbuildopts="-v1.18.4-2" --extra-package=${HOME}backports/libgstreamer1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gstreamer-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-dev_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-plugins-base1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libgstreamer-gl1.0-0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-gl_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-gst-plugins-base-1.0_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-good_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gstreamer1.0-plugins-base_1.20.1-1~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libnice-dev_0.1.18-2~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libnice10_0.1.18-2~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/gir1.2-nice-0.1_0.1.18-2~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libopenh264-6_2.2.0+dfsg-2~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libopenh264-dev_2.2.0+dfsg-2~bpo11+1_${ARCH}.deb --extra-package=${HOME}backports/libfreeaptx0_0.1.1-1_${ARCH}.deb --extra-package=${HOME}backports/libfreeaptx-dev_0.1.1-1_${ARCH}.deb --pre-build-commands='%SBUILD_CHROOT_EXEC sh -c "mkdir -p /usr/include/opencv4/opencv2/video/detail"' --pre-build-commands='cat ${HOME}tracking.private.hpp | %SBUILD_CHROOT_EXEC sh -c "cat > /usr/include/opencv4/opencv2/video/detail/tracking.private.hpp"'
+
+
+
+Move all debs for each arch into their own directory and generate package list. I use "$HOME/apt_root_${ARCH}".
+    dpkg-scanpackages --arch=${ARCH} . /dev/null | gzip -9c > Packages.gz
+
+
+Modify download_packages.py and add an apt source line:
+    deb [trusted=yes] file:${HOME}apt_root_amd64 ./
+
+
+download_packages.py is broken when a deb has mutually exclusive dependencies. In our case, we can use either libsoup2.4 or libsoup3. At the time of writing, it would be much more difficult to setup libsoup3 so exclude it.
+
+Finally, run:
+    ./download_packages.py --arch ${ARCH} --release bullseye-backports --exclude=libsoup3.0-0 gstreamer1.0-plugins-bad gstreamer1.0-plugins-good gstreamer1.0-plugins-ugly gstreamer1.0-plugins-base libgstreamer-plugins-bad1.0-dev libgstreamer-plugins-base1.0-dev gstreamer1.0-nice libgstreamer1.0-0 libgstreamer1.0-dev libsoup2.4-dev libjson-glib-dev
diff --git a/frc971/analysis/plot_data_utils.ts b/frc971/analysis/plot_data_utils.ts
index 230e370..80c4cca 100644
--- a/frc971/analysis/plot_data_utils.ts
+++ b/frc971/analysis/plot_data_utils.ts
@@ -5,7 +5,7 @@
 import {ByteBuffer} from 'flatbuffers';
 import {Plot, Point} from 'org_frc971/aos/network/www/plotter';
 import {Connection} from 'org_frc971/aos/network/www/proxy';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 
 export function plotData(conn: Connection, parentDiv: Element) {
   // Set up a selection box to allow the user to choose between plots to show.
diff --git a/frc971/control_loops/capped_test_plant.h b/frc971/control_loops/capped_test_plant.h
index 65bc7cc..f4286cd 100644
--- a/frc971/control_loops/capped_test_plant.h
+++ b/frc971/control_loops/capped_test_plant.h
@@ -29,4 +29,4 @@
 
 }  // namespace frc971
 }  // namespace control_loops
-#endif  // FRC971_CONTROL_LOOPS_CAPPED_TEST_PLANT_H_
\ No newline at end of file
+#endif  // FRC971_CONTROL_LOOPS_CAPPED_TEST_PLANT_H_
diff --git a/frc971/control_loops/hybrid_state_feedback_loop.h b/frc971/control_loops/hybrid_state_feedback_loop.h
index fd39359..46e6a05 100644
--- a/frc971/control_loops/hybrid_state_feedback_loop.h
+++ b/frc971/control_loops/hybrid_state_feedback_loop.h
@@ -39,7 +39,7 @@
       const Eigen::Matrix<Scalar, number_of_outputs, number_of_states> &C,
       const Eigen::Matrix<Scalar, number_of_outputs, number_of_inputs> &D,
       const Eigen::Matrix<Scalar, number_of_inputs, 1> &U_max,
-      const Eigen::Matrix<Scalar, number_of_inputs, 1> &U_min, bool delayed_u)
+      const Eigen::Matrix<Scalar, number_of_inputs, 1> &U_min, size_t delayed_u)
       : A_continuous(A_continuous),
         B_continuous(B_continuous),
         C(C),
@@ -55,7 +55,7 @@
   const Eigen::Matrix<Scalar, number_of_inputs, 1> U_min;
   const Eigen::Matrix<Scalar, number_of_inputs, 1> U_max;
 
-  const bool delayed_u;
+  const size_t delayed_u;
 };
 
 template <int number_of_states, int number_of_inputs, int number_of_outputs,
@@ -230,7 +230,7 @@
   const Eigen::Matrix<Scalar, number_of_states, number_of_states>
       P_steady_state;
 
-  const bool delayed_u;
+  const size_t delayed_u;
 
   HybridKalmanCoefficients(
       const Eigen::Matrix<Scalar, number_of_states, number_of_states>
@@ -238,7 +238,7 @@
       const Eigen::Matrix<Scalar, number_of_outputs, number_of_outputs>
           &R_continuous,
       const Eigen::Matrix<Scalar, number_of_states, number_of_states>
-          &P_steady_state, bool delayed_u)
+          &P_steady_state, size_t delayed_u)
       : Q_continuous(Q_continuous),
         R_continuous(R_continuous),
         P_steady_state(P_steady_state), delayed_u(delayed_u) {
diff --git a/frc971/control_loops/python/control_loop.py b/frc971/control_loops/python/control_loop.py
index f431983..1649dd2 100644
--- a/frc971/control_loops/python/control_loop.py
+++ b/frc971/control_loops/python/control_loop.py
@@ -266,7 +266,7 @@
             name: string, The name of the loop to use when writing the C++ files.
         """
         self._name = name
-        self.delayed_u = False
+        self.delayed_u = 0
 
     @property
     def name(self):
@@ -291,7 +291,7 @@
         self.X = numpy.matrix(numpy.zeros((self.A.shape[0], 1)))
         self.Y = self.C * self.X
         self.X_hat = numpy.matrix(numpy.zeros((self.A.shape[0], 1)))
-        self.last_U = numpy.matrix(numpy.zeros((self.B.shape[1], 1)))
+        self.last_U = numpy.matrix(numpy.zeros((self.B.shape[1], max(1, self.delayed_u))))
 
     def PlaceControllerPoles(self, poles):
         """Places the controller poles.
@@ -314,19 +314,21 @@
     def Update(self, U):
         """Simulates one time step with the provided U."""
         #U = numpy.clip(U, self.U_min, self.U_max)
-        if self.delayed_u:
-            self.X = self.A * self.X + self.B * self.last_U
-            self.Y = self.C * self.X + self.D * self.last_U
-            self.last_U = U.copy()
+        if self.delayed_u > 0:
+            self.X = self.A * self.X + self.B * self.last_U[:, -1]
+            self.Y = self.C * self.X + self.D * self.last_U[:, -1]
+            self.last_U[:, 1:] = self.last_U[:, 0:-1]
+            self.last_U[:, 0] = U.copy()
         else:
             self.X = self.A * self.X + self.B * U
             self.Y = self.C * self.X + self.D * U
 
     def PredictObserver(self, U):
         """Runs the predict step of the observer update."""
-        if self.delayed_u:
-            self.X_hat = (self.A * self.X_hat + self.B * self.last_U)
-            self.last_U = U.copy()
+        if self.delayed_u > 0:
+            self.X_hat = (self.A * self.X_hat + self.B * self.last_U[:, -1])
+            self.last_U[:, 1:] = self.last_U[:, 0:-1]
+            self.last_U[:, 0] = U.copy()
         else:
             self.X_hat = (self.A * self.X_hat + self.B * U)
 
@@ -336,9 +338,9 @@
             KalmanGain = self.KalmanGain
         else:
             KalmanGain = numpy.linalg.inv(self.A) * self.L
-        if self.delayed_u:
+        if self.delayed_u > 0:
             self.X_hat += KalmanGain * (self.Y - self.C * self.X_hat -
-                                        self.D * self.last_U)
+                                        self.D * self.last_U[:, -1])
         else:
             self.X_hat += KalmanGain * (self.Y - self.C * self.X_hat -
                                         self.D * U)
@@ -396,7 +398,7 @@
         ans.append(self._DumpMatrix('U_max', self.U_max, scalar_type))
         ans.append(self._DumpMatrix('U_min', self.U_min, scalar_type))
 
-        delayed_u_string = "true" if self.delayed_u else "false"
+        delayed_u_string = str(self.delayed_u)
         if plant_coefficient_type.startswith('StateFeedbackPlant'):
             ans.append(self._DumpMatrix('A', self.A, scalar_type))
             ans.append(self._DumpMatrix('B', self.B, scalar_type))
@@ -492,7 +494,7 @@
             '%s %s {\n' % (observer_coefficient_type, self.ObserverFunction())
         ]
 
-        delayed_u_string = "true" if self.delayed_u else "false"
+        delayed_u_string = str(self.delayed_u)
         if observer_coefficient_type.startswith('StateFeedbackObserver'):
             if hasattr(self, 'KalmanGain'):
                 KalmanGain = self.KalmanGain
@@ -540,9 +542,10 @@
 
     def PredictHybridObserver(self, U, dt):
         self.Discretize(dt)
-        if self.delayed_u:
-            self.X_hat = self.A * self.X_hat + self.B * self.last_U
-            self.last_U = U.copy()
+        if self.delayed_u > 0:
+            self.X_hat = self.A * self.X_hat + self.B * self.last_U[:, -1]
+            self.last_U[:, 1:] = self.last_U[:, 0:-1]
+            self.last_U[:, 0] = U.copy()
         else:
             self.X_hat = self.A * self.X_hat + self.B * U
 
diff --git a/frc971/control_loops/state_feedback_loop.h b/frc971/control_loops/state_feedback_loop.h
index 53cd6a2..1ea94d9 100644
--- a/frc971/control_loops/state_feedback_loop.h
+++ b/frc971/control_loops/state_feedback_loop.h
@@ -12,6 +12,7 @@
 
 #if defined(__linux__)
 #include "aos/logging/logging.h"
+#include "glog/logging.h"
 #endif
 #include "aos/macros.h"
 
@@ -49,7 +50,7 @@
       const Eigen::Matrix<Scalar, number_of_outputs, number_of_inputs> &D,
       const Eigen::Matrix<Scalar, number_of_inputs, 1> &U_max,
       const Eigen::Matrix<Scalar, number_of_inputs, 1> &U_min,
-      const std::chrono::nanoseconds dt, bool delayed_u)
+      const std::chrono::nanoseconds dt, size_t delayed_u)
       : A(A),
         B(B),
         C(C),
@@ -71,7 +72,7 @@
   // useful for modeling a control loop cycle where you sample, compute, and
   // then queue the outputs to be ready to be executed when the next cycle
   // happens.
-  const bool delayed_u;
+  const size_t delayed_u;
 };
 
 template <int number_of_states, int number_of_inputs, int number_of_outputs,
@@ -85,6 +86,16 @@
           number_of_states, number_of_inputs, number_of_outputs, Scalar>>>
           &&coefficients)
       : coefficients_(::std::move(coefficients)), index_(0) {
+    if (coefficients_.size() > 1u) {
+      for (size_t i = 1; i < coefficients_.size(); ++i) {
+        if (coefficients_[i]->delayed_u != coefficients_[0]->delayed_u) {
+          abort();
+        }
+      }
+    }
+    last_U_ = Eigen::Matrix<Scalar, number_of_inputs, Eigen::Dynamic>(
+        number_of_inputs,
+        std::max(static_cast<size_t>(1u), coefficients_[0]->delayed_u));
     Reset();
   }
 
@@ -175,15 +186,27 @@
     }
   }
 
+  const Eigen::Matrix<Scalar, number_of_inputs, 1> last_U(
+      size_t index = 0) const {
+    return last_U_.template block<number_of_inputs, 1>(0, index);
+  }
+
   // Computes the new X and Y given the control input.
   void Update(const Eigen::Matrix<Scalar, number_of_inputs, 1> &U) {
     // Powers outside of the range are more likely controller bugs than things
     // that the plant should deal with.
     CheckU(U);
-    if (coefficients().delayed_u) {
-      X_ = Update(X(), last_U_);
-      UpdateY(last_U_);
-      last_U_ = U;
+    if (coefficients().delayed_u > 0) {
+#if defined(__linux__)
+      DCHECK_EQ(static_cast<ssize_t>(coefficients().delayed_u), last_U_.cols());
+#endif
+      X_ = Update(X(), last_U(coefficients().delayed_u - 1));
+      UpdateY(last_U(coefficients().delayed_u - 1));
+      for (int i = coefficients().delayed_u; i > 1; --i) {
+        last_U_.template block<number_of_inputs, 1>(0, i - 1) =
+            last_U_.template block<number_of_inputs, 1>(0, i - 2);
+      }
+      last_U_.template block<number_of_inputs, 1>(0, 0) = U;
     } else {
       X_ = Update(X(), U);
       UpdateY(U);
@@ -210,7 +233,7 @@
  private:
   Eigen::Matrix<Scalar, number_of_states, 1> X_;
   Eigen::Matrix<Scalar, number_of_outputs, 1> Y_;
-  Eigen::Matrix<Scalar, number_of_inputs, 1> last_U_;
+  Eigen::Matrix<Scalar, number_of_inputs, Eigen::Dynamic> last_U_;
 
   ::std::vector<::std::unique_ptr<StateFeedbackPlantCoefficients<
       number_of_states, number_of_inputs, number_of_outputs, Scalar>>>
@@ -310,14 +333,14 @@
   // useful for modeling a control loop cycle where you sample, compute, and
   // then queue the outputs to be ready to be executed when the next cycle
   // happens.
-  const bool delayed_u;
+  const size_t delayed_u;
 
   StateFeedbackObserverCoefficients(
       const Eigen::Matrix<Scalar, number_of_states, number_of_outputs>
           &KalmanGain,
       const Eigen::Matrix<Scalar, number_of_states, number_of_states> &Q,
       const Eigen::Matrix<Scalar, number_of_outputs, number_of_outputs> &R,
-      bool delayed_u)
+      size_t delayed_u)
       : KalmanGain(KalmanGain), Q(Q), R(R), delayed_u(delayed_u) {}
 };
 
@@ -331,7 +354,10 @@
       ::std::vector<::std::unique_ptr<StateFeedbackObserverCoefficients<
           number_of_states, number_of_inputs, number_of_outputs, Scalar>>>
           &&observers)
-      : coefficients_(::std::move(observers)) {}
+      : coefficients_(::std::move(observers)) {
+    last_U_ = Eigen::Matrix<Scalar, number_of_inputs, Eigen::Dynamic>(
+        number_of_inputs, std::max(static_cast<size_t>(1u), coefficients().delayed_u));
+  }
 
   StateFeedbackObserver(StateFeedbackObserver &&other)
       : X_hat_(other.X_hat_), last_U_(other.last_U_), index_(other.index_) {
@@ -349,8 +375,9 @@
   }
   Eigen::Matrix<Scalar, number_of_states, 1> &mutable_X_hat() { return X_hat_; }
 
-  const Eigen::Matrix<Scalar, number_of_inputs, 1> &last_U() const {
-    return last_U_;
+  const Eigen::Matrix<Scalar, number_of_inputs, 1> last_U(
+      size_t index = 0) const {
+    return last_U_.template block<number_of_inputs, 1>(0, index);
   }
 
   void Reset(StateFeedbackPlant<number_of_states, number_of_inputs,
@@ -363,9 +390,14 @@
                                   number_of_outputs, Scalar> *plant,
                const Eigen::Matrix<Scalar, number_of_inputs, 1> &new_u,
                ::std::chrono::nanoseconds /*dt*/) {
-    if (plant->coefficients().delayed_u) {
-      mutable_X_hat() = plant->Update(X_hat(), last_U_);
-      last_U_ = new_u;
+    if (plant->coefficients().delayed_u > 0) {
+      mutable_X_hat() =
+          plant->Update(X_hat(), last_U(coefficients().delayed_u - 1));
+      for (int i = coefficients().delayed_u; i > 1; --i) {
+        last_U_.template block<number_of_inputs, 1>(0, i - 1) =
+            last_U_.template block<number_of_inputs, 1>(0, i - 2);
+      }
+      last_U_.template block<number_of_inputs, 1>(0, 0) = new_u;
     } else {
       mutable_X_hat() = plant->Update(X_hat(), new_u);
     }
@@ -406,7 +438,7 @@
  private:
   // Internal state estimate.
   Eigen::Matrix<Scalar, number_of_states, 1> X_hat_;
-  Eigen::Matrix<Scalar, number_of_inputs, 1> last_U_;
+  Eigen::Matrix<Scalar, number_of_inputs, Eigen::Dynamic> last_U_;
 
   int index_ = 0;
   ::std::vector<::std::unique_ptr<StateFeedbackObserverCoefficients<
diff --git a/frc971/raspi/rootfs/target_configure.sh b/frc971/raspi/rootfs/target_configure.sh
index 06f481b..3b71112 100755
--- a/frc971/raspi/rootfs/target_configure.sh
+++ b/frc971/raspi/rootfs/target_configure.sh
@@ -17,6 +17,8 @@
 chown -R pi.pi /home/pi/.ssh
 chown -R pi.pi /home/pi/bin
 
+echo 'deb [trusted=yes] https://software.frc971.org/Build-Dependencies/gstreamer_bullseye_arm64_deps ./' >> /etc/apt/sources.list
+
 apt-get update
 
 apt-get install -y vim-nox \
@@ -43,9 +45,17 @@
   libnice10 \
   pmount \
   libnice-dev \
-  feh
+  feh \
+  libgstreamer1.0-0 \
+  libgstreamer-plugins-base1.0-0 \
+  libgstreamer-plugins-bad1.0-0 \
+  gstreamer1.0-plugins-base \
+  gstreamer1.0-plugins-good \
+  gstreamer1.0-plugins-bad \
+  gstreamer1.0-plugins-ugly \
+  gstreamer1.0-nice
 
-dpkg -i /tmp/wiringpi-2.70-1.deb
+PATH=$PATH:/sbin dpkg -i /tmp/wiringpi-2.70-1.deb
 
 echo 'GOVERNOR="performance"' > /etc/default/cpufrequtils
 
diff --git a/frc971/wpilib/ahal/Spark.cc b/frc971/wpilib/ahal/Spark.cc
index deb891b..502ff31 100644
--- a/frc971/wpilib/ahal/Spark.cc
+++ b/frc971/wpilib/ahal/Spark.cc
@@ -26,7 +26,7 @@
    *   0.999ms = full "reverse"
    */
   SetBounds(2.003, 1.55, 1.50, 1.46, .999);
-  SetPeriodMultiplier(kPeriodMultiplier_1X);
+  SetPeriodMultiplier(kPeriodMultiplier_2X);
   SetSpeed(0.0);
   SetZeroLatch();
 
diff --git a/frc971/wpilib/ahal/Talon.cc b/frc971/wpilib/ahal/Talon.cc
index e3af567..7caabc0 100644
--- a/frc971/wpilib/ahal/Talon.cc
+++ b/frc971/wpilib/ahal/Talon.cc
@@ -32,7 +32,7 @@
    *   0.989ms = full "reverse"
    */
   SetBounds(2.037, 1.539, 1.513, 1.487, .989);
-  SetPeriodMultiplier(kPeriodMultiplier_1X);
+  SetPeriodMultiplier(kPeriodMultiplier_2X);
   SetSpeed(0.0);
   SetZeroLatch();
 
diff --git a/frc971/wpilib/ahal/TalonFX.cc b/frc971/wpilib/ahal/TalonFX.cc
index 93dc62e..fe29089 100644
--- a/frc971/wpilib/ahal/TalonFX.cc
+++ b/frc971/wpilib/ahal/TalonFX.cc
@@ -33,7 +33,7 @@
    *   0.997ms = full "reverse"
    */
   SetBounds(2.004, 1.52, 1.50, 1.48, .997);
-  SetPeriodMultiplier(kPeriodMultiplier_1X);
+  SetPeriodMultiplier(kPeriodMultiplier_2X);
   SetSpeed(0.0);
   SetZeroLatch();
 
diff --git a/frc971/wpilib/ahal/VictorSP.cc b/frc971/wpilib/ahal/VictorSP.cc
index fee03a9..249202d 100644
--- a/frc971/wpilib/ahal/VictorSP.cc
+++ b/frc971/wpilib/ahal/VictorSP.cc
@@ -33,7 +33,7 @@
    *   0.997ms = full "reverse"
    */
   SetBounds(2.004, 1.52, 1.50, 1.48, .997);
-  SetPeriodMultiplier(kPeriodMultiplier_1X);
+  SetPeriodMultiplier(kPeriodMultiplier_2X);
   SetSpeed(0.0);
   SetZeroLatch();
 
diff --git a/frc971/wpilib/imu_plot_utils.ts b/frc971/wpilib/imu_plot_utils.ts
index 08b3c13..c4b516b 100644
--- a/frc971/wpilib/imu_plot_utils.ts
+++ b/frc971/wpilib/imu_plot_utils.ts
@@ -5,7 +5,7 @@
 import {Point} from 'org_frc971/aos/network/www/plotter';
 import {Table} from 'org_frc971/aos/network/www/reflection';
 import {ByteBuffer} from 'flatbuffers';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 
 const FILTER_WINDOW_SIZE = 100;
 
diff --git a/frc971/wpilib/sensor_reader.cc b/frc971/wpilib/sensor_reader.cc
index 6c47214..bb99dc8 100644
--- a/frc971/wpilib/sensor_reader.cc
+++ b/frc971/wpilib/sensor_reader.cc
@@ -14,6 +14,9 @@
 #include "frc971/wpilib/wpilib_interface.h"
 #include "hal/PWM.h"
 
+DEFINE_int32(pwm_offset, 5050 / 2,
+             "Offset of reading the sensors from the start of the PWM cycle");
+
 namespace frc971 {
 namespace wpilib {
 
@@ -125,12 +128,17 @@
     last_monotonic_now_ = monotonic_now;
 
     monotonic_clock::time_point last_tick_timepoint = GetPWMStartTime();
+    VLOG(1) << "Start time " << last_tick_timepoint << " period " << period_.count();
     if (last_tick_timepoint == monotonic_clock::min_time) {
       return;
     }
 
     last_tick_timepoint +=
-        ((monotonic_now - last_tick_timepoint) / period_) * period_;
+        ((monotonic_now - chrono::microseconds(FLAGS_pwm_offset) -
+          last_tick_timepoint) /
+         period_) *
+        period_ + chrono::microseconds(FLAGS_pwm_offset);
+    VLOG(1) << "Now " << monotonic_now << " tick " << last_tick_timepoint;
     // If it's over 1/2 of a period back in time, that's wrong.  Move it
     // forwards to now.
     if (last_tick_timepoint - monotonic_now < -period_ / 2) {
@@ -142,7 +150,7 @@
     // errors in waking up.  The PWM cycle starts at the falling edge of the
     // PWM pulse.
     const auto next_time =
-        last_tick_timepoint + period_ + chrono::microseconds(50);
+        last_tick_timepoint + period_;
 
     timer_handler_->Setup(next_time, period_);
   }
diff --git a/scouting/BUILD b/scouting/BUILD
index c543c17..f58a157 100644
--- a/scouting/BUILD
+++ b/scouting/BUILD
@@ -1,10 +1,5 @@
 load("//tools/build_rules:apache.bzl", "apache_wrapper")
-load("//tools/build_rules:js.bzl", "protractor_ts_test", "turn_files_into_runfiles")
-
-turn_files_into_runfiles(
-    name = "main_bundle_compiled_runfiles",
-    files = "//scouting/www:main_bundle_compiled",
-)
+load("//tools/build_rules:js.bzl", "protractor_ts_test")
 
 sh_binary(
     name = "scouting",
@@ -12,7 +7,6 @@
         "scouting.sh",
     ],
     data = [
-        ":main_bundle_compiled_runfiles",
         "//scouting/webserver",
         "//scouting/www:static_files",
     ],
diff --git a/scouting/db/db.go b/scouting/db/db.go
index 85395e1..d3faa58 100644
--- a/scouting/db/db.go
+++ b/scouting/db/db.go
@@ -50,6 +50,12 @@
 	Notes      []string
 }
 
+type Ranking struct {
+	TeamNumber         int
+	Losses, Wins, Ties int32
+	Rank, Dq           int32
+}
+
 // Opens a database at the specified port on localhost. We currently don't
 // support connecting to databases on other hosts.
 func NewDatabase(user string, password string, port int) (*Database, error) {
@@ -138,6 +144,24 @@
 		return nil, errors.New(fmt.Sprint("Failed to create notes table: ", err))
 	}
 
+	statement, err = database.Prepare("CREATE TABLE IF NOT EXISTS rankings (" +
+		"id SERIAL PRIMARY KEY, " +
+		"Losses INTEGER, " +
+		"Wins INTEGER, " +
+		"Ties INTEGER, " +
+		"Rank INTEGER, " +
+		"Dq INTEGER, " +
+		"TeamNumber INTEGER)")
+	if err != nil {
+		return nil, errors.New(fmt.Sprint("Failed to prepare rankings table creation: ", err))
+	}
+	defer statement.Close()
+
+	_, err = statement.Exec()
+	if err != nil {
+		return nil, errors.New(fmt.Sprint("Failed to create rankings table: ", err))
+	}
+
 	return database, nil
 }
 
@@ -169,6 +193,16 @@
 		return errors.New(fmt.Sprint("Failed to drop notes table: ", err))
 	}
 	return nil
+
+	statement, err = database.Prepare("DROP TABLE IF EXISTS rankings")
+	if err != nil {
+		return errors.New(fmt.Sprint("Failed to prepare dropping rankings table: ", err))
+	}
+	_, err = statement.Exec()
+	if err != nil {
+		return errors.New(fmt.Sprint("Failed to drop rankings table: ", err))
+	}
+	return nil
 }
 
 // This function will also populate the Stats table with six empty rows every time a match is added
@@ -278,6 +312,48 @@
 	return nil
 }
 
+func (database *Database) AddOrUpdateRankings(r Ranking) error {
+	statement, err := database.Prepare("UPDATE rankings SET " +
+		"Losses = $1, Wins = $2, Ties = $3, " +
+		"Rank = $4, Dq = $5, TeamNumber = $6 " +
+		"WHERE TeamNumber = $6")
+	if err != nil {
+		return errors.New(fmt.Sprint("Failed to prepare rankings database update: ", err))
+	}
+	defer statement.Close()
+
+	result, err := statement.Exec(r.Losses, r.Wins, r.Ties,
+		r.Rank, r.Dq, r.TeamNumber)
+	if err != nil {
+		return errors.New(fmt.Sprint("Failed to update rankings database: ", err))
+	}
+
+	numRowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return errors.New(fmt.Sprint("Failed to query rows affected: ", err))
+	}
+	if numRowsAffected == 0 {
+		statement, err := database.Prepare("INSERT INTO rankings(" +
+			"Losses, Wins, Ties, " +
+			"Rank, Dq, TeamNumber) " +
+			"VALUES (" +
+			"$1, $2, $3, " +
+			"$4, $5, $6)")
+		if err != nil {
+			return errors.New(fmt.Sprint("Failed to prepare insertion into rankings database: ", err))
+		}
+		defer statement.Close()
+
+		_, err = statement.Exec(r.Losses, r.Wins, r.Ties,
+			r.Rank, r.Dq, r.TeamNumber)
+		if err != nil {
+			return errors.New(fmt.Sprint("Failed to insert into rankings database: ", err))
+		}
+	}
+
+	return nil
+}
+
 func (database *Database) ReturnMatches() ([]Match, error) {
 	rows, err := database.Query("SELECT * FROM matches")
 	if err != nil {
@@ -328,6 +404,28 @@
 	return teams, nil
 }
 
+func (database *Database) ReturnRankings() ([]Ranking, error) {
+	rows, err := database.Query("SELECT * FROM rankings")
+	if err != nil {
+		return nil, errors.New(fmt.Sprint("Failed to SELECT * FROM rankings: ", err))
+	}
+	defer rows.Close()
+
+	all_rankings := make([]Ranking, 0)
+	for rows.Next() {
+		var ranking Ranking
+		var id int
+		err = rows.Scan(&id,
+			&ranking.Losses, &ranking.Wins, &ranking.Ties,
+			&ranking.Rank, &ranking.Dq, &ranking.TeamNumber)
+		if err != nil {
+			return nil, errors.New(fmt.Sprint("Failed to scan from rankings: ", err))
+		}
+		all_rankings = append(all_rankings, ranking)
+	}
+	return all_rankings, nil
+}
+
 func (database *Database) QueryMatches(teamNumber_ int32) ([]Match, error) {
 	rows, err := database.Query("SELECT * FROM matches WHERE "+
 		"R1 = $1 OR R2 = $2 OR R3 = $3 OR B1 = $4 OR B2 = $5 OR B3 = $6",
@@ -400,6 +498,28 @@
 	return NotesData{TeamNumber, notes}, nil
 }
 
+func (database *Database) QueryRankings(TeamNumber int) ([]Ranking, error) {
+	rows, err := database.Query("SELECT * FROM rankings WHERE TeamNumber = $1", TeamNumber)
+	if err != nil {
+		return nil, errors.New(fmt.Sprint("Failed to select from rankings: ", err))
+	}
+	defer rows.Close()
+
+	all_rankings := make([]Ranking, 0)
+	for rows.Next() {
+		var ranking Ranking
+		var id int
+		err = rows.Scan(&id,
+			&ranking.Losses, &ranking.Wins, &ranking.Ties,
+			&ranking.Rank, &ranking.Dq, &ranking.TeamNumber)
+		if err != nil {
+			return nil, errors.New(fmt.Sprint("Failed to scan from rankings: ", err))
+		}
+		all_rankings = append(all_rankings, ranking)
+	}
+	return all_rankings, nil
+}
+
 func (database *Database) AddNotes(data NotesData) error {
 	if len(data.Notes) > 1 {
 		return errors.New("Can only insert one row of notes at a time")
diff --git a/scouting/db/db_test.go b/scouting/db/db_test.go
index 02e8d50..5725dcb 100644
--- a/scouting/db/db_test.go
+++ b/scouting/db/db_test.go
@@ -82,6 +82,36 @@
 	}
 }
 
+func TestAddOrUpdateRankingsDB(t *testing.T) {
+	fixture := createDatabase(t)
+	defer fixture.TearDown()
+
+	correct := []Ranking{
+		Ranking{
+			TeamNumber: 123,
+			Losses:     1, Wins: 7, Ties: 0,
+			Rank: 2, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 125,
+			Losses:     2, Wins: 4, Ties: 0,
+			Rank: 2, Dq: 0,
+		},
+	}
+
+	for i := 0; i < len(correct); i++ {
+		err := fixture.db.AddOrUpdateRankings(correct[i])
+		check(t, err, "Failed to add ranking data")
+	}
+
+	got, err := fixture.db.ReturnRankings()
+	check(t, err, "Failed ReturnRankings()")
+
+	if !reflect.DeepEqual(correct, got) {
+		t.Fatalf("Got %#v,\nbut expected %#v.", got, correct)
+	}
+}
+
 func TestAddToStatsDB(t *testing.T) {
 	fixture := createDatabase(t)
 	defer fixture.TearDown()
@@ -283,6 +313,54 @@
 	}
 }
 
+func TestQueryRankingsDB(t *testing.T) {
+	fixture := createDatabase(t)
+	defer fixture.TearDown()
+
+	testDatabase := []Ranking{
+		Ranking{
+			TeamNumber: 123,
+			Losses:     1, Wins: 7, Ties: 2,
+			Rank: 2, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 124,
+			Losses:     3, Wins: 4, Ties: 0,
+			Rank: 4, Dq: 2,
+		},
+		Ranking{
+			TeamNumber: 125,
+			Losses:     5, Wins: 2, Ties: 0,
+			Rank: 17, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 126,
+			Losses:     0, Wins: 7, Ties: 0,
+			Rank: 5, Dq: 0,
+		},
+	}
+
+	for i := 0; i < len(testDatabase); i++ {
+		err := fixture.db.AddOrUpdateRankings(testDatabase[i])
+		check(t, err, fmt.Sprint("Failed to add rankings ", i))
+	}
+
+	correct := []Ranking{
+		Ranking{
+			TeamNumber: 126,
+			Losses:     0, Wins: 7, Ties: 0,
+			Rank: 5, Dq: 0,
+		},
+	}
+
+	got, err := fixture.db.QueryRankings(126)
+	check(t, err, "Failed QueryRankings()")
+
+	if !reflect.DeepEqual(correct, got) {
+		t.Errorf("Got %#v,\nbut expected %#v.", got, correct)
+	}
+}
+
 func TestReturnMatchDB(t *testing.T) {
 	fixture := createDatabase(t)
 	defer fixture.TearDown()
@@ -328,6 +406,46 @@
 	}
 }
 
+func TestReturnRankingsDB(t *testing.T) {
+	fixture := createDatabase(t)
+	defer fixture.TearDown()
+
+	correct := []Ranking{
+		Ranking{
+			TeamNumber: 123,
+			Losses:     1, Wins: 7, Ties: 2,
+			Rank: 2, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 124,
+			Losses:     3, Wins: 4, Ties: 0,
+			Rank: 4, Dq: 2,
+		},
+		Ranking{
+			TeamNumber: 125,
+			Losses:     5, Wins: 2, Ties: 0,
+			Rank: 17, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 126,
+			Losses:     0, Wins: 7, Ties: 0,
+			Rank: 5, Dq: 0,
+		},
+	}
+
+	for i := 0; i < len(correct); i++ {
+		err := fixture.db.AddOrUpdateRankings(correct[i])
+		check(t, err, fmt.Sprint("Failed to add rankings", i))
+	}
+
+	got, err := fixture.db.ReturnRankings()
+	check(t, err, "Failed ReturnRankings()")
+
+	if !reflect.DeepEqual(correct, got) {
+		t.Errorf("Got %#v,\nbut expected %#v.", got, correct)
+	}
+}
+
 func TestReturnStatsDB(t *testing.T) {
 	fixture := createDatabase(t)
 	defer fixture.TearDown()
@@ -400,6 +518,59 @@
 	}
 }
 
+func TestRankingsDbUpdate(t *testing.T) {
+	fixture := createDatabase(t)
+	defer fixture.TearDown()
+
+	testDatabase := []Ranking{
+		Ranking{
+			TeamNumber: 123,
+			Losses:     1, Wins: 7, Ties: 2,
+			Rank: 2, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 124,
+			Losses:     3, Wins: 4, Ties: 0,
+			Rank: 4, Dq: 2,
+		},
+		Ranking{
+			TeamNumber: 125,
+			Losses:     5, Wins: 2, Ties: 0,
+			Rank: 17, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 126,
+			Losses:     0, Wins: 7, Ties: 0,
+			Rank: 5, Dq: 0,
+		},
+		Ranking{
+			TeamNumber: 125,
+			Losses:     2, Wins: 4, Ties: 1,
+			Rank: 5, Dq: 0,
+		},
+	}
+
+	for i := 0; i < len(testDatabase); i++ {
+		err := fixture.db.AddOrUpdateRankings(testDatabase[i])
+		check(t, err, fmt.Sprint("Failed to add rankings ", i))
+	}
+
+	correct := []Ranking{
+		Ranking{
+			TeamNumber: 125,
+			Losses:     2, Wins: 4, Ties: 1,
+			Rank: 5, Dq: 0,
+		},
+	}
+
+	got, err := fixture.db.QueryRankings(125)
+	check(t, err, "Failed QueryRankings()")
+
+	if !reflect.DeepEqual(correct, got) {
+		t.Errorf("Got %#v,\nbut expected %#v.", got, correct)
+	}
+}
+
 func TestNotes(t *testing.T) {
 	fixture := createDatabase(t)
 	defer fixture.TearDown()
diff --git a/scouting/scraping/scrape.go b/scouting/scraping/scrape.go
index 170fe50..19426cf 100644
--- a/scouting/scraping/scrape.go
+++ b/scouting/scraping/scrape.go
@@ -17,14 +17,14 @@
 	BaseUrl string `json:"base_url"`
 }
 
-// Takes in year and FIRST event code and returns all matches in that event according to TBA.
+// Takes in year and FIRST event code and returns requested information according to TBA.
 // Also takes in a file path to the JSON config file that contains your TBA API key.
 // It defaults to <workspace root>/config.json
 // the config is expected to have the following contents:
 //{
 //    api_key:"myTBAapiKey"
 //}
-func AllMatches(year int32, eventCode, configPath string) ([]Match, error) {
+func getJson(year int32, eventCode, configPath, category string) ([]byte, error) {
 	if configPath == "" {
 		configPath = os.Getenv("BUILD_WORKSPACE_DIRECTORY") + "/scouting_config.json"
 	}
@@ -52,7 +52,7 @@
 	eventKey := strconv.Itoa(int(year)) + eventCode
 
 	// Create a get request for the match info.
-	req, err := http.NewRequest("GET", config.BaseUrl+"/api/v3/event/"+eventKey+"/matches", nil)
+	req, err := http.NewRequest("GET", config.BaseUrl+"/api/v3/event/"+eventKey+"/"+category, nil)
 	if err != nil {
 		return nil, errors.New(fmt.Sprint("Failed to build http request: ", err))
 	}
@@ -78,6 +78,17 @@
 		return nil, errors.New(fmt.Sprint("Failed to read TBA API response: ", err))
 	}
 
+	return bodyBytes, nil
+}
+
+// Return all matches in event according to TBA
+func AllMatches(year int32, eventCode, configPath string) ([]Match, error) {
+	bodyBytes, err := getJson(year, eventCode, configPath, "matches")
+
+	if err != nil {
+		return nil, err
+	}
+
 	var matches []Match
 	// Unmarshal json into go usable format.
 	if err := json.Unmarshal([]byte(bodyBytes), &matches); err != nil {
@@ -86,3 +97,20 @@
 
 	return matches, nil
 }
+
+// Return event rankings according to TBA
+func AllRankings(year int32, eventCode, configPath string) (EventRanking, error) {
+	bodyBytes, err := getJson(year, eventCode, configPath, "rankings")
+
+	if err != nil {
+		return EventRanking{}, err
+	}
+
+	var rankings EventRanking
+	// Unmarshal json into go usable format.
+	if err := json.Unmarshal([]byte(bodyBytes), &rankings); err != nil {
+		return EventRanking{}, errors.New(fmt.Sprint("Failed to parse JSON received from TBA: ", err))
+	}
+
+	return rankings, nil
+}
diff --git a/scouting/scraping/scraping_demo.go b/scouting/scraping/scraping_demo.go
index 0ea3e53..69cdbff 100644
--- a/scouting/scraping/scraping_demo.go
+++ b/scouting/scraping/scraping_demo.go
@@ -13,22 +13,43 @@
 
 func main() {
 	jsonPtr := flag.Bool("json", false, "If set, dump as JSON, rather than Go debug output.")
+	demoCategory := flag.String("category", "matches", "Decide whether to demo matches or rankings.")
+
 	flag.Parse()
 
-	// Get all the matches.
-	matches, err := scraping.AllMatches(2016, "nytr", "")
-	if err != nil {
-		log.Fatal("Failed to scrape match list: ", err)
-	}
-
-	// Dump the matches.
-	if *jsonPtr {
-		jsonData, err := json.MarshalIndent(matches, "", "  ")
+	if *demoCategory == "rankings" {
+		// Get all the rankings.
+		rankings, err := scraping.AllRankings(2016, "nytr", "")
 		if err != nil {
-			log.Fatal("Failed to turn match list into JSON: ", err)
+			log.Fatal("Failed to scrape ranking list: ", err)
 		}
-		fmt.Println(string(jsonData))
-	} else {
-		spew.Dump(matches)
+
+		// Dump the rankings.
+		if *jsonPtr {
+			jsonData, err := json.MarshalIndent(rankings, "", "  ")
+			if err != nil {
+				log.Fatal("Failed to turn ranking list into JSON: ", err)
+			}
+			fmt.Println(string(jsonData))
+		} else {
+			spew.Dump(rankings)
+		}
+	} else if *demoCategory == "matches" {
+		// Get all the matches.
+		matches, err := scraping.AllMatches(2016, "nytr", "")
+		if err != nil {
+			log.Fatal("Failed to scrape match list: ", err)
+		}
+
+		// Dump the matches.
+		if *jsonPtr {
+			jsonData, err := json.MarshalIndent(matches, "", "  ")
+			if err != nil {
+				log.Fatal("Failed to turn match list into JSON: ", err)
+			}
+			fmt.Println(string(jsonData))
+		} else {
+			spew.Dump(matches)
+		}
 	}
 }
diff --git a/scouting/scraping/types.go b/scouting/scraping/types.go
index aa0d4be..d8a79f1 100644
--- a/scouting/scraping/types.go
+++ b/scouting/scraping/types.go
@@ -1,5 +1,26 @@
 package scraping
 
+type EventRanking struct {
+	Rankings []Rank `json:"rankings"`
+}
+
+type Rank struct {
+	MatchesPlayed int32     `json:"matches_played"`
+	QualAverage   int32     `json:"qual_average"`
+	ExtraStats    []float64 `json:"extra_stats"`
+	SortOrders    []float64 `json:"sort_orders"`
+	Records       Record    `json:"record"`
+	Rank          int32     `json:"rank"`
+	Dq            int32     `json:"dq"`
+	TeamKey       string    `json:"team_key"`
+}
+
+type Record struct {
+	Losses int32 `json:"losses"`
+	Wins   int32 `json:"wins"`
+	Ties   int32 `json:"ties"`
+}
+
 // Match holds the TBA data for a given match
 type Match struct {
 	Key             string
diff --git a/scouting/webserver/requests/debug/BUILD b/scouting/webserver/requests/debug/BUILD
index e5f5234..6adaee5 100644
--- a/scouting/webserver/requests/debug/BUILD
+++ b/scouting/webserver/requests/debug/BUILD
@@ -15,5 +15,6 @@
         "//scouting/webserver/requests/messages:request_notes_for_team_response_go_fbs",
         "//scouting/webserver/requests/messages:submit_data_scouting_response_go_fbs",
         "//scouting/webserver/requests/messages:submit_notes_response_go_fbs",
+        "@com_github_google_flatbuffers//go:go_default_library",
     ],
 )
diff --git a/scouting/webserver/requests/debug/cli/main.go b/scouting/webserver/requests/debug/cli/main.go
index 6f2de1d..f6fb38a 100644
--- a/scouting/webserver/requests/debug/cli/main.go
+++ b/scouting/webserver/requests/debug/cli/main.go
@@ -65,6 +65,18 @@
 	return binaryFb
 }
 
+func maybePerformRequest[T interface{}](fbName, fbsPath, requestJsonPath, address string, requester func(string, []byte) (*T, error)) {
+	if requestJsonPath != "" {
+		log.Printf("Sending %s to %s", fbName, address)
+		binaryRequest := parseJson(fbsPath, requestJsonPath)
+		response, err := requester(address, binaryRequest)
+		if err != nil {
+			log.Fatalf("Failed %s: %v", fbName, err)
+		}
+		spew.Dump(*response)
+	}
+}
+
 func main() {
 	// Parse command line arguments.
 	indentPtr := flag.String("indent", " ",
@@ -86,59 +98,38 @@
 	spew.Config.Indent = *indentPtr
 
 	// Handle the actual arguments.
-	if *submitDataScoutingPtr != "" {
-		log.Printf("Sending SubmitDataScouting to %s", *addressPtr)
-		binaryRequest := parseJson(
-			"scouting/webserver/requests/messages/submit_data_scouting.fbs",
-			*submitDataScoutingPtr)
-		response, err := debug.SubmitDataScouting(*addressPtr, binaryRequest)
-		if err != nil {
-			log.Fatal("Failed SubmitDataScouting: ", err)
-		}
-		spew.Dump(*response)
-	}
-	if *requestAllMatchesPtr != "" {
-		log.Printf("Sending RequestAllMatches to %s", *addressPtr)
-		binaryRequest := parseJson(
-			"scouting/webserver/requests/messages/request_all_matches.fbs",
-			*requestAllMatchesPtr)
-		response, err := debug.RequestAllMatches(*addressPtr, binaryRequest)
-		if err != nil {
-			log.Fatal("Failed RequestAllMatches: ", err)
-		}
-		spew.Dump(*response)
-	}
-	if *requestMatchesForTeamPtr != "" {
-		log.Printf("Sending RequestMatchesForTeam to %s", *addressPtr)
-		binaryRequest := parseJson(
-			"scouting/webserver/requests/messages/request_matches_for_team.fbs",
-			*requestMatchesForTeamPtr)
-		response, err := debug.RequestMatchesForTeam(*addressPtr, binaryRequest)
-		if err != nil {
-			log.Fatal("Failed RequestMatchesForTeam: ", err)
-		}
-		spew.Dump(*response)
-	}
-	if *requestDataScoutingPtr != "" {
-		log.Printf("Sending RequestDataScouting to %s", *addressPtr)
-		binaryRequest := parseJson(
-			"scouting/webserver/requests/messages/request_data_scouting.fbs",
-			*requestDataScoutingPtr)
-		response, err := debug.RequestDataScouting(*addressPtr, binaryRequest)
-		if err != nil {
-			log.Fatal("Failed RequestDataScouting: ", err)
-		}
-		spew.Dump(*response)
-	}
-	if *refreshMatchListPtr != "" {
-		log.Printf("Sending RefreshMatchList to %s", *addressPtr)
-		binaryRequest := parseJson(
-			"scouting/webserver/requests/messages/refresh_match_list.fbs",
-			*refreshMatchListPtr)
-		response, err := debug.RefreshMatchList(*addressPtr, binaryRequest)
-		if err != nil {
-			log.Fatal("Failed RefreshMatchList: ", err)
-		}
-		spew.Dump(*response)
-	}
+	maybePerformRequest(
+		"SubmitDataScouting",
+		"scouting/webserver/requests/messages/submit_data_scouting.fbs",
+		*submitDataScoutingPtr,
+		*addressPtr,
+		debug.SubmitDataScouting)
+
+	maybePerformRequest(
+		"RequestAllMatches",
+		"scouting/webserver/requests/messages/request_all_matches.fbs",
+		*requestAllMatchesPtr,
+		*addressPtr,
+		debug.RequestAllMatches)
+
+	maybePerformRequest(
+		"RequestMatchesForTeam",
+		"scouting/webserver/requests/messages/request_matches_for_team.fbs",
+		*requestMatchesForTeamPtr,
+		*addressPtr,
+		debug.RequestMatchesForTeam)
+
+	maybePerformRequest(
+		"RequestDataScouting",
+		"scouting/webserver/requests/messages/request_data_scouting.fbs",
+		*requestDataScoutingPtr,
+		*addressPtr,
+		debug.RequestDataScouting)
+
+	maybePerformRequest(
+		"RefreshMatchList",
+		"scouting/webserver/requests/messages/refresh_match_list.fbs",
+		*refreshMatchListPtr,
+		*addressPtr,
+		debug.RefreshMatchList)
 }
diff --git a/scouting/webserver/requests/debug/debug.go b/scouting/webserver/requests/debug/debug.go
index 63ece72..21f0f05 100644
--- a/scouting/webserver/requests/debug/debug.go
+++ b/scouting/webserver/requests/debug/debug.go
@@ -17,6 +17,7 @@
 	"github.com/frc971/971-Robot-Code/scouting/webserver/requests/messages/request_notes_for_team_response"
 	"github.com/frc971/971-Robot-Code/scouting/webserver/requests/messages/submit_data_scouting_response"
 	"github.com/frc971/971-Robot-Code/scouting/webserver/requests/messages/submit_notes_response"
+	flatbuffers "github.com/google/flatbuffers/go"
 )
 
 // The username to submit the various requests as.
@@ -90,82 +91,55 @@
 	return responseBytes, nil
 }
 
-// Sends a `SubmitDataScouting` message to the server and returns the
-// deserialized response.
+// Sends a message to the server and returns the deserialized response.
+// The first generic argument must be specified.
+func sendMessage[FbT interface{}, Fb interface{ UnPack() *FbT }](url string, requestBytes []byte, parser func([]byte, flatbuffers.UOffsetT) Fb) (*FbT, error) {
+	responseBytes, err := performPost(url, requestBytes)
+	if err != nil {
+		return nil, err
+	}
+	response := parser(responseBytes, 0)
+	return response.UnPack(), nil
+}
+
 func SubmitDataScouting(server string, requestBytes []byte) (*submit_data_scouting_response.SubmitDataScoutingResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/submit/data_scouting", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Parsing SubmitDataScoutingResponse")
-	response := submit_data_scouting_response.GetRootAsSubmitDataScoutingResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[submit_data_scouting_response.SubmitDataScoutingResponseT](
+		server+"/requests/submit/data_scouting", requestBytes,
+		submit_data_scouting_response.GetRootAsSubmitDataScoutingResponse)
 }
 
-// Sends a `RequestAllMatches` message to the server and returns the
-// deserialized response.
 func RequestAllMatches(server string, requestBytes []byte) (*request_all_matches_response.RequestAllMatchesResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/request/all_matches", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Parsing RequestAllMatchesResponse")
-	response := request_all_matches_response.GetRootAsRequestAllMatchesResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[request_all_matches_response.RequestAllMatchesResponseT](
+		server+"/requests/request/all_matches", requestBytes,
+		request_all_matches_response.GetRootAsRequestAllMatchesResponse)
 }
 
-// Sends a `RequestMatchesForTeam` message to the server and returns the
-// deserialized response.
 func RequestMatchesForTeam(server string, requestBytes []byte) (*request_matches_for_team_response.RequestMatchesForTeamResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/request/matches_for_team", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Parsing RequestMatchesForTeamResponse")
-	response := request_matches_for_team_response.GetRootAsRequestMatchesForTeamResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[request_matches_for_team_response.RequestMatchesForTeamResponseT](
+		server+"/requests/request/matches_for_team", requestBytes,
+		request_matches_for_team_response.GetRootAsRequestMatchesForTeamResponse)
 }
 
-// Sends a `RequestDataScouting` message to the server and returns the
-// deserialized response.
 func RequestDataScouting(server string, requestBytes []byte) (*request_data_scouting_response.RequestDataScoutingResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/request/data_scouting", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Parsing RequestDataScoutingResponse")
-	response := request_data_scouting_response.GetRootAsRequestDataScoutingResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[request_data_scouting_response.RequestDataScoutingResponseT](
+		server+"/requests/request/data_scouting", requestBytes,
+		request_data_scouting_response.GetRootAsRequestDataScoutingResponse)
 }
 
-// Sends a `RefreshMatchList` message to the server and returns the
-// deserialized response.
 func RefreshMatchList(server string, requestBytes []byte) (*refresh_match_list_response.RefreshMatchListResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/refresh_match_list", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Parsing RefreshMatchListResponse")
-	response := refresh_match_list_response.GetRootAsRefreshMatchListResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[refresh_match_list_response.RefreshMatchListResponseT](
+		server+"/requests/refresh_match_list", requestBytes,
+		refresh_match_list_response.GetRootAsRefreshMatchListResponse)
 }
 
 func SubmitNotes(server string, requestBytes []byte) (*submit_notes_response.SubmitNotesResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/submit/submit_notes", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	response := submit_notes_response.GetRootAsSubmitNotesResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[submit_notes_response.SubmitNotesResponseT](
+		server+"/requests/submit/submit_notes", requestBytes,
+		submit_notes_response.GetRootAsSubmitNotesResponse)
 }
 
 func RequestNotes(server string, requestBytes []byte) (*request_notes_for_team_response.RequestNotesForTeamResponseT, error) {
-	responseBytes, err := performPost(server+"/requests/request/notes_for_team", requestBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	response := request_notes_for_team_response.GetRootAsRequestNotesForTeamResponse(responseBytes, 0)
-	return response.UnPack(), nil
+	return sendMessage[request_notes_for_team_response.RequestNotesForTeamResponseT](
+		server+"/requests/request/notes_for_team", requestBytes,
+		request_notes_for_team_response.GetRootAsRequestNotesForTeamResponse)
 }
diff --git a/scouting/webserver/requests/requests.go b/scouting/webserver/requests/requests.go
index c9a6880..d67f5e9 100644
--- a/scouting/webserver/requests/requests.go
+++ b/scouting/webserver/requests/requests.go
@@ -79,16 +79,15 @@
 	respondWithError(w, http.StatusNotImplemented, "")
 }
 
-// TODO(phil): Can we turn this into a generic?
-func parseSubmitDataScouting(w http.ResponseWriter, buf []byte) (*SubmitDataScouting, bool) {
+func parseRequest[T interface{}](w http.ResponseWriter, buf []byte, requestName string, parser func([]byte, flatbuffers.UOffsetT) *T) (*T, bool) {
 	success := true
 	defer func() {
 		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse SubmitDataScouting: %v", r))
+			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse %s: %v", requestName, r))
 			success = false
 		}
 	}()
-	result := submit_data_scouting.GetRootAsSubmitDataScouting(buf, 0)
+	result := parser(buf, 0)
 	return result, success
 }
 
@@ -135,7 +134,7 @@
 		return
 	}
 
-	request, success := parseSubmitDataScouting(w, requestBytes)
+	request, success := parseRequest[SubmitDataScouting](w, requestBytes, "SubmitDataScouting", submit_data_scouting.GetRootAsSubmitDataScouting)
 	if !success {
 		return
 	}
@@ -181,19 +180,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-// TODO(phil): Can we turn this into a generic?
-func parseRequestAllMatches(w http.ResponseWriter, buf []byte) (*RequestAllMatches, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse SubmitDataScouting: %v", r))
-			success = false
-		}
-	}()
-	result := request_all_matches.GetRootAsRequestAllMatches(buf, 0)
-	return result, success
-}
-
 // Handles a RequestAllMaches request.
 type requestAllMatchesHandler struct {
 	db Database
@@ -206,7 +192,7 @@
 		return
 	}
 
-	_, success := parseRequestAllMatches(w, requestBytes)
+	_, success := parseRequest(w, requestBytes, "RequestAllMatches", request_all_matches.GetRootAsRequestAllMatches)
 	if !success {
 		return
 	}
@@ -237,19 +223,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-// TODO(phil): Can we turn this into a generic?
-func parseRequestMatchesForTeam(w http.ResponseWriter, buf []byte) (*RequestMatchesForTeam, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse SubmitDataScouting: %v", r))
-			success = false
-		}
-	}()
-	result := request_matches_for_team.GetRootAsRequestMatchesForTeam(buf, 0)
-	return result, success
-}
-
 // Handles a RequestMatchesForTeam request.
 type requestMatchesForTeamHandler struct {
 	db Database
@@ -262,7 +235,7 @@
 		return
 	}
 
-	request, success := parseRequestMatchesForTeam(w, requestBytes)
+	request, success := parseRequest(w, requestBytes, "RequestMatchesForTeam", request_matches_for_team.GetRootAsRequestMatchesForTeam)
 	if !success {
 		return
 	}
@@ -293,19 +266,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-// TODO(phil): Can we turn this into a generic?
-func parseRequestDataScouting(w http.ResponseWriter, buf []byte) (*RequestDataScouting, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse SubmitDataScouting: %v", r))
-			success = false
-		}
-	}()
-	result := request_data_scouting.GetRootAsRequestDataScouting(buf, 0)
-	return result, success
-}
-
 // Handles a RequestDataScouting request.
 type requestDataScoutingHandler struct {
 	db Database
@@ -318,7 +278,7 @@
 		return
 	}
 
-	_, success := parseRequestDataScouting(w, requestBytes)
+	_, success := parseRequest(w, requestBytes, "RequestDataScouting", request_data_scouting.GetRootAsRequestDataScouting)
 	if !success {
 		return
 	}
@@ -359,19 +319,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-// TODO(phil): Can we turn this into a generic?
-func parseRefreshMatchList(w http.ResponseWriter, buf []byte) (*RefreshMatchList, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse RefreshMatchList: %v", r))
-			success = false
-		}
-	}()
-	result := refresh_match_list.GetRootAsRefreshMatchList(buf, 0)
-	return result, success
-}
-
 func parseTeamKey(teamKey string) (int, error) {
 	// TBA prefixes teams with "frc". Not sure why. Get rid of that.
 	teamKey = strings.TrimPrefix(teamKey, "frc")
@@ -422,7 +369,7 @@
 		return
 	}
 
-	request, success := parseRefreshMatchList(w, requestBytes)
+	request, success := parseRequest(w, requestBytes, "RefreshMatchList", refresh_match_list.GetRootAsRefreshMatchList)
 	if !success {
 		return
 	}
@@ -467,18 +414,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-func parseSubmitNotes(w http.ResponseWriter, buf []byte) (*SubmitNotes, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse RefreshMatchList: %v", r))
-			success = false
-		}
-	}()
-	result := submit_notes.GetRootAsSubmitNotes(buf, 0)
-	return result, success
-}
-
 type submitNoteScoutingHandler struct {
 	db Database
 }
@@ -490,7 +425,7 @@
 		return
 	}
 
-	request, success := parseSubmitNotes(w, requestBytes)
+	request, success := parseRequest(w, requestBytes, "SubmitNotes", submit_notes.GetRootAsSubmitNotes)
 	if !success {
 		return
 	}
@@ -510,18 +445,6 @@
 	w.Write(builder.FinishedBytes())
 }
 
-func parseRequestNotesForTeam(w http.ResponseWriter, buf []byte) (*RequestNotesForTeam, bool) {
-	success := true
-	defer func() {
-		if r := recover(); r != nil {
-			respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Failed to parse RefreshMatchList: %v", r))
-			success = false
-		}
-	}()
-	result := request_notes_for_team.GetRootAsRequestNotesForTeam(buf, 0)
-	return result, success
-}
-
 type requestNotesForTeamHandler struct {
 	db Database
 }
@@ -533,7 +456,7 @@
 		return
 	}
 
-	request, success := parseRequestNotesForTeam(w, requestBytes)
+	request, success := parseRequest(w, requestBytes, "RequestNotesForTeam", request_notes_for_team.GetRootAsRequestNotesForTeam)
 	if !success {
 		return
 	}
diff --git a/scouting/webserver/static/BUILD b/scouting/webserver/static/BUILD
index 3166853..0cf22f3 100644
--- a/scouting/webserver/static/BUILD
+++ b/scouting/webserver/static/BUILD
@@ -13,6 +13,7 @@
     name = "static_test",
     srcs = ["static_test.go"],
     data = [
+        "test_pages/index.html",
         "test_pages/page.txt",
         "test_pages/root.txt",
     ],
diff --git a/scouting/webserver/static/static.go b/scouting/webserver/static/static.go
index e921b0b..4c46fe7 100644
--- a/scouting/webserver/static/static.go
+++ b/scouting/webserver/static/static.go
@@ -2,13 +2,137 @@
 
 // A year agnostic way to serve static http files.
 import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"io"
+	"log"
 	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
 
 	"github.com/frc971/971-Robot-Code/scouting/webserver/server"
 )
 
-// Serve pages given a port, directory to serve from, and an channel to pass the errors back to the caller.
+// We want the static files (which include JS that is modified over time), to not be cached.
+// This ensures users get updated versions when uploaded to the server.
+// Based on https://stackoverflow.com/a/33881296, this disables cache for most browsers.
+var epoch = time.Unix(0, 0).Format(time.RFC1123)
+
+var noCacheHeaders = map[string]string{
+	"Expires":         epoch,
+	"Cache-Control":   "no-cache, private, max-age=0",
+	"Pragma":          "no-cache",
+	"X-Accel-Expires": "0",
+}
+
+func MaybeNoCache(h http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		// We force the browser not to cache index.html so that
+		// browsers will notice when the bundle gets updated.
+		if r.URL.Path == "/" || r.URL.Path == "/index.html" {
+			for k, v := range noCacheHeaders {
+				w.Header().Set(k, v)
+			}
+		}
+
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
+
+// Computes the sha256 of the specified file.
+func computeSha256(path string) (string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", errors.New(fmt.Sprint("Failed to open ", path, ": ", err))
+	}
+	defer file.Close()
+
+	hash := sha256.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", errors.New(fmt.Sprint("Failed to compute sha256 of ", path, ": ", err))
+	}
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+// Finds the checksums for all the files in the specified directory. This is a
+// best effort only. If for some reason we fail to compute the checksum of
+// something, we just move on.
+func findAllFileShas(directory string) map[string]string {
+	shaSums := make(map[string]string)
+
+	// Find the checksums for all the files.
+	err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			log.Println("Walk() didn't want to deal with ", path, ":", err)
+			return nil
+		}
+		if info.IsDir() {
+			// We only care about computing checksums of files.
+			// Ignore directories.
+			return nil
+		}
+		hash, err := computeSha256(path)
+		if err != nil {
+			log.Println(err)
+			return nil
+		}
+		shaSums[hash] = "/" + strings.TrimPrefix(path, directory)
+		return nil
+	})
+	if err != nil {
+		log.Fatal("Got unexpected error from Walk(): ", err)
+	}
+
+	return shaSums
+}
+
+func HandleShaUrl(directory string, h http.Handler) http.Handler {
+	shaSums := findAllFileShas(directory)
+
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		// We expect the path portion to look like this:
+		// /sha256/<checksum>/path...
+		// Splitting on / means we end up with this list:
+		// [0] ""
+		// [1] "sha256"
+		// [2] "<checksum>"
+		// [3-] path...
+		parts := strings.Split(r.URL.Path, "/")
+		if len(parts) < 4 {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		if parts[0] != "" || parts[1] != "sha256" {
+			// Something is fundamentally wrong. We told the
+			// framework to only give is /sha256/ requests.
+			log.Fatal("This handler should not be called for " + r.URL.Path)
+		}
+		hash := parts[2]
+		if path, ok := shaSums[hash]; ok {
+			// We found a file with this checksum. Serve that file.
+			r.URL.Path = path
+		} else {
+			// No file with this checksum found.
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+
+		h.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
+
+// Serve pages in the specified directory.
 func ServePages(scoutingServer server.ScoutingServer, directory string) {
 	// Serve the / endpoint given a folder of pages.
-	scoutingServer.Handle("/", http.FileServer(http.Dir(directory)))
+	scoutingServer.Handle("/", MaybeNoCache(http.FileServer(http.Dir(directory))))
+
+	// Also serve files in a checksum-addressable manner.
+	scoutingServer.Handle("/sha256/", HandleShaUrl(directory, http.FileServer(http.Dir(directory))))
 }
diff --git a/scouting/webserver/static/static_test.go b/scouting/webserver/static/static_test.go
index 15bd872..09ed940 100644
--- a/scouting/webserver/static/static_test.go
+++ b/scouting/webserver/static/static_test.go
@@ -9,6 +9,12 @@
 	"github.com/frc971/971-Robot-Code/scouting/webserver/server"
 )
 
+func expectEqual(t *testing.T, actual string, expected string) {
+	if actual != expected {
+		t.Error("Expected ", actual, " to equal ", expected)
+	}
+}
+
 func TestServing(t *testing.T) {
 	cases := []struct {
 		// The path to request from the server.
@@ -17,6 +23,7 @@
 		// specified path.
 		expectedData string
 	}{
+		{"/", "<h1>This is the index</h1>\n"},
 		{"/root.txt", "Hello, this is the root page!"},
 		{"/page.txt", "Hello from a page!"},
 	}
@@ -24,16 +31,67 @@
 	scoutingServer := server.NewScoutingServer()
 	ServePages(scoutingServer, "test_pages")
 	scoutingServer.Start(8080)
+	defer scoutingServer.Stop()
 
 	// Go through all the test cases, and run them against the running webserver.
 	for _, c := range cases {
 		dataReceived := getData(c.path, t)
-		if dataReceived != c.expectedData {
-			t.Errorf("Got %q, but expected %q", dataReceived, c.expectedData)
-		}
+		expectEqual(t, dataReceived, c.expectedData)
 	}
+}
 
-	scoutingServer.Stop()
+// Makes sure that requesting / sets the proper headers so it doesn't get
+// cached.
+func TestDisallowedCache(t *testing.T) {
+	scoutingServer := server.NewScoutingServer()
+	ServePages(scoutingServer, "test_pages")
+	scoutingServer.Start(8080)
+	defer scoutingServer.Stop()
+
+	resp, err := http.Get("http://localhost:8080/")
+	if err != nil {
+		t.Fatal("Failed to get data ", err)
+	}
+	expectEqual(t, resp.Header.Get("Expires"), "Thu, 01 Jan 1970 00:00:00 UTC")
+	expectEqual(t, resp.Header.Get("Cache-Control"), "no-cache, private, max-age=0")
+	expectEqual(t, resp.Header.Get("Pragma"), "no-cache")
+	expectEqual(t, resp.Header.Get("X-Accel-Expires"), "0")
+}
+
+// Makes sure that requesting anything other than / doesn't set the "do not
+// cache" headers.
+func TestAllowedCache(t *testing.T) {
+	scoutingServer := server.NewScoutingServer()
+	ServePages(scoutingServer, "test_pages")
+	scoutingServer.Start(8080)
+	defer scoutingServer.Stop()
+
+	resp, err := http.Get("http://localhost:8080/root.txt")
+	if err != nil {
+		t.Fatalf("Failed to get data ", err)
+	}
+	expectEqual(t, resp.Header.Get("Expires"), "")
+	expectEqual(t, resp.Header.Get("Cache-Control"), "")
+	expectEqual(t, resp.Header.Get("Pragma"), "")
+	expectEqual(t, resp.Header.Get("X-Accel-Expires"), "")
+}
+
+func TestSha256(t *testing.T) {
+	scoutingServer := server.NewScoutingServer()
+	ServePages(scoutingServer, "test_pages")
+	scoutingServer.Start(8080)
+	defer scoutingServer.Stop()
+
+	// Validate a valid checksum.
+	dataReceived := getData("sha256/553b9b29647a112136986cf93c57b988d1f12dc43d3b774f14a24e58d272dbff/root.txt", t)
+	expectEqual(t, dataReceived, "Hello, this is the root page!")
+
+	// Make a request with an invalid checksum and make sure we get a 404.
+	resp, err := http.Get("http://localhost:8080/sha256/0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef/root.txt")
+	if err != nil {
+		t.Fatal("Failed to get data ", err)
+	}
+	expectEqual(t, resp.Status, "404 Not Found")
 }
 
 // Retrieves the data at the specified path. If an error occurs, the test case
@@ -45,7 +103,7 @@
 	}
 	// Error out if the return status is anything other than 200 OK.
 	if resp.Status != "200 OK" {
-		t.Fatalf("Received a status code other than 200")
+		t.Fatal("Received a status code other than 200:", resp.Status)
 	}
 	// Read the response body.
 	body, err := ioutil.ReadAll(resp.Body)
diff --git a/scouting/webserver/static/test_pages/index.html b/scouting/webserver/static/test_pages/index.html
new file mode 100644
index 0000000..d769db4
--- /dev/null
+++ b/scouting/webserver/static/test_pages/index.html
@@ -0,0 +1 @@
+<h1>This is the index</h1>
diff --git a/scouting/www/BUILD b/scouting/www/BUILD
index 99dcde6..b14c29b 100644
--- a/scouting/www/BUILD
+++ b/scouting/www/BUILD
@@ -1,6 +1,5 @@
 load("@npm//@bazel/typescript:index.bzl", "ts_library")
 load("//tools/build_rules:js.bzl", "rollup_bundle")
-load("@npm//@bazel/concatjs:index.bzl", "concatjs_devserver")
 load("@npm//@babel/cli:index.bzl", "babel")
 
 ts_library(
@@ -21,6 +20,8 @@
         "//scouting/www/import_match_list",
         "//scouting/www/match_list",
         "//scouting/www/notes",
+        "//scouting/www/shift_schedule",
+        "//scouting/www/view",
         "@npm//@angular/animations",
         "@npm//@angular/common",
         "@npm//@angular/core",
@@ -39,19 +40,54 @@
 babel(
     name = "main_bundle_compiled",
     args = [
-        "$(execpath :main_bundle)",
+        "$(execpath :main_bundle.min.js)",
         "--no-babelrc",
         "--source-maps",
+        "--minified",
+        "--no-comments",
         "--plugins=@angular/compiler-cli/linker/babel",
         "--out-dir",
         "$(@D)",
     ],
     data = [
-        ":main_bundle",
+        ":main_bundle.min.js",
         "@npm//@angular/compiler-cli",
     ],
     output_dir = True,
-    visibility = ["//visibility:public"],
+)
+
+# The babel() rule above puts everything into a directory without telling bazel
+# what's in the directory. That makes it annoying to work with from other
+# rules. This genrule() here copies the one file in the directory we care about
+# so that other rules have an easier time using the file.
+genrule(
+    name = "main_bundle_file",
+    srcs = [":main_bundle_compiled"],
+    outs = ["main_bundle_file.js"],
+    cmd = "cp $(location :main_bundle_compiled)/main_bundle.min.js $(OUTS)",
+)
+
+py_binary(
+    name = "index_html_generator",
+    srcs = ["index_html_generator.py"],
+)
+
+genrule(
+    name = "generate_index_html",
+    srcs = [
+        "index.template.html",
+        "main_bundle_file.js",
+    ],
+    outs = ["index.html"],
+    cmd = " ".join([
+        "$(location :index_html_generator)",
+        "--template $(location index.template.html)",
+        "--bundle $(location main_bundle_file.js)",
+        "--output $(location index.html)",
+    ]),
+    tools = [
+        ":index_html_generator",
+    ],
 )
 
 # Create a copy of zone.js here so that we can have a predictable path to
@@ -82,20 +118,12 @@
     srcs = [
         "index.html",
         ":field_pictures_copy",
+        ":main_bundle_file.js",
         ":zonejs_copy",
     ],
     visibility = ["//visibility:public"],
 )
 
-concatjs_devserver(
-    name = "devserver",
-    serving_path = "/main_bundle.js",
-    static_files = [
-        ":static_files",
-    ],
-    deps = [":main_bundle_compiled"],
-)
-
 filegroup(
     name = "common_css",
     srcs = ["common.css"],
diff --git a/scouting/www/app.ng.html b/scouting/www/app.ng.html
index ab1e433..3c9c2c2 100644
--- a/scouting/www/app.ng.html
+++ b/scouting/www/app.ng.html
@@ -46,6 +46,24 @@
       Import Match List
     </a>
   </li>
+  <li class="nav-item">
+    <a
+      class="nav-link"
+      [class.active]="tabIs('ShiftSchedule')"
+      (click)="switchTabToGuarded('ShiftSchedule')"
+    >
+      Shift Schedule
+    </a>
+  </li>
+  <li class="nav-item">
+    <a
+      class="nav-link"
+      [class.active]="tabIs('View')"
+      (click)="switchTabToGuarded('View')"
+    >
+      View
+    </a>
+  </li>
 </ul>
 
 <ng-container [ngSwitch]="tab">
@@ -63,4 +81,9 @@
   <app-import-match-list
     *ngSwitchCase="'ImportMatchList'"
   ></app-import-match-list>
+  <shift-schedule *ngSwitchCase="'ShiftSchedule'"></shift-schedule>
+  <app-view
+    (switchTabsEvent)="switchTabTo($event)"
+    *ngSwitchCase="'View'"
+  ></app-view>
 </ng-container>
diff --git a/scouting/www/app.ts b/scouting/www/app.ts
index 02af125..9d6c539 100644
--- a/scouting/www/app.ts
+++ b/scouting/www/app.ts
@@ -1,6 +1,16 @@
 import {Component, ElementRef, ViewChild} from '@angular/core';
 
-type Tab = 'MatchList' | 'Notes' | 'Entry' | 'ImportMatchList';
+type Tab =
+  | 'MatchList'
+  | 'Notes'
+  | 'Entry'
+  | 'ImportMatchList'
+  | 'ShiftSchedule'
+  | 'View';
+
+// Ignore the guard for tabs that don't require the user to enter any data.
+const unguardedTabs: Tab[] = ['MatchList', 'ImportMatchList'];
+
 type TeamInMatch = {
   teamNumber: number;
   matchNumber: number;
@@ -24,12 +34,14 @@
 
   constructor() {
     window.addEventListener('beforeunload', (e) => {
-      if (!this.block_alerts.nativeElement.checked) {
-        // Based on
-        // https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onbeforeunload#example
-        // This combination ensures a dialog will be shown on most browsers.
-        e.preventDefault();
-        e.returnValue = '';
+      if (!unguardedTabs.includes(this.tab)) {
+        if (!this.block_alerts.nativeElement.checked) {
+          // Based on
+          // https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onbeforeunload#example
+          // This combination ensures a dialog will be shown on most browsers.
+          e.preventDefault();
+          e.returnValue = '';
+        }
       }
     });
   }
@@ -46,8 +58,12 @@
   switchTabToGuarded(tab: Tab) {
     let shouldSwitch = true;
     if (this.tab !== tab) {
-      if (!this.block_alerts.nativeElement.checked) {
-        shouldSwitch = window.confirm('Leave current page?');
+      if (!unguardedTabs.includes(this.tab)) {
+        if (!this.block_alerts.nativeElement.checked) {
+          shouldSwitch = window.confirm(
+            'Leave current page? You will lose all data.'
+          );
+        }
       }
     }
     if (shouldSwitch) {
diff --git a/scouting/www/app_module.ts b/scouting/www/app_module.ts
index 9c762f6..8c18f7a 100644
--- a/scouting/www/app_module.ts
+++ b/scouting/www/app_module.ts
@@ -7,6 +7,8 @@
 import {ImportMatchListModule} from './import_match_list/import_match_list.module';
 import {MatchListModule} from './match_list/match_list.module';
 import {NotesModule} from './notes/notes.module';
+import {ShiftScheduleModule} from './shift_schedule/shift_schedule.module';
+import {ViewModule} from './view/view.module';
 
 @NgModule({
   declarations: [App],
@@ -17,6 +19,8 @@
     NotesModule,
     ImportMatchListModule,
     MatchListModule,
+    ShiftScheduleModule,
+    ViewModule,
   ],
   exports: [App],
   bootstrap: [App],
diff --git a/scouting/www/entry/entry.ng.html b/scouting/www/entry/entry.ng.html
index 0e76268..b8eaa78 100644
--- a/scouting/www/entry/entry.ng.html
+++ b/scouting/www/entry/entry.ng.html
@@ -37,7 +37,10 @@
 
   <div *ngSwitchCase="'Auto'" id="auto" class="container-fluid">
     <div class="row">
-      <img src="/pictures/field/quadrants.jpeg" alt="Quadrants Image" />
+      <img
+        src="/sha256/cbb99a057a2504e80af526dae7a0a04121aed84c56a6f4889e9576fe1c20c61e/pictures/field/quadrants.jpeg"
+        alt="Quadrants Image"
+      />
       <form>
         <input
           type="radio"
@@ -75,7 +78,10 @@
       </form>
     </div>
     <div class="row">
-      <img src="/pictures/field/balls.jpeg" alt="Image" />
+      <img
+        src="/sha256/e095cc8a75d804b0e2070e0a941fab37154176756d4c1a775e53cc48c3a732b9/pictures/field/balls.jpeg"
+        alt="Image"
+      />
       <form>
         <!--Choice for each ball location-->
         <input
diff --git a/scouting/www/index.html b/scouting/www/index.html
deleted file mode 100644
index 84777d1..0000000
--- a/scouting/www/index.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>FRC971 Scouting Application</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <base href="/" />
-    <script src="./npm/node_modules/zone.js/dist/zone.min.js"></script>
-    <link
-      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
-      rel="stylesheet"
-      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
-      crossorigin="anonymous"
-    />
-  </head>
-  <body>
-    <my-app></my-app>
-    <script src="./main_bundle_compiled/main_bundle.js"></script>
-  </body>
-</html>
diff --git a/scouting/www/index.template.html b/scouting/www/index.template.html
new file mode 100644
index 0000000..303dca1
--- /dev/null
+++ b/scouting/www/index.template.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>FRC971 Scouting Application</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <base href="/" />
+    <script src="./npm/node_modules/zone.js/dist/zone.min.js"></script>
+    <link
+      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
+      rel="stylesheet"
+      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
+      crossorigin="anonymous"
+    />
+  </head>
+  <body>
+    <my-app></my-app>
+    <!-- The path here is auto-generated to be /sha256/<checksum>/main_bundle_file.js. -->
+    <script src="{MAIN_BUNDLE_FILE}"></script>
+  </body>
+</html>
diff --git a/scouting/www/index_html_generator.py b/scouting/www/index_html_generator.py
new file mode 100644
index 0000000..3b057fd
--- /dev/null
+++ b/scouting/www/index_html_generator.py
@@ -0,0 +1,28 @@
+"""Generates index.html with the right checksum for main_bundle_file.js filled in."""
+
+import argparse
+import hashlib
+import sys
+from pathlib import Path
+
+def compute_sha256(filepath):
+    return hashlib.sha256(filepath.read_bytes()).hexdigest()
+
+def main(argv):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--template", type=str)
+    parser.add_argument("--bundle", type=str)
+    parser.add_argument("--output", type=str)
+    args = parser.parse_args(argv[1:])
+
+    template = Path(args.template).read_text()
+    bundle_path = Path(args.bundle)
+    bundle_sha256 = compute_sha256(bundle_path)
+
+    output = template.format(
+        MAIN_BUNDLE_FILE = f"/sha256/{bundle_sha256}/{bundle_path.name}",
+    )
+    Path(args.output).write_text(output)
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
diff --git a/scouting/www/shift_schedule/BUILD b/scouting/www/shift_schedule/BUILD
new file mode 100644
index 0000000..8fe99e4
--- /dev/null
+++ b/scouting/www/shift_schedule/BUILD
@@ -0,0 +1,27 @@
+load("@npm//@bazel/typescript:index.bzl", "ts_library")
+
+ts_library(
+    name = "shift_schedule",
+    srcs = [
+        "shift_schedule.component.ts",
+        "shift_schedule.module.ts",
+    ],
+    angular_assets = [
+        "shift_schedule.component.css",
+        "shift_schedule.ng.html",
+        "//scouting/www:common_css",
+    ],
+    compiler = "//tools:tsc_wrapped_with_angular",
+    target_compatible_with = ["@platforms//cpu:x86_64"],
+    use_angular_plugin = True,
+    visibility = ["//visibility:public"],
+    deps = [
+        "//scouting/webserver/requests/messages:error_response_ts_fbs",
+        "//scouting/webserver/requests/messages:request_all_matches_response_ts_fbs",
+        "//scouting/webserver/requests/messages:request_all_matches_ts_fbs",
+        "@com_github_google_flatbuffers//ts:flatbuffers_ts",
+        "@npm//@angular/common",
+        "@npm//@angular/core",
+        "@npm//@angular/forms",
+    ],
+)
diff --git a/scouting/www/shift_schedule/shift_schedule.component.css b/scouting/www/shift_schedule/shift_schedule.component.css
new file mode 100644
index 0000000..bafeb4c
--- /dev/null
+++ b/scouting/www/shift_schedule/shift_schedule.component.css
@@ -0,0 +1,17 @@
+* {
+  padding: 5px;
+}
+
+.badge {
+  height: 20px;
+}
+
+.red {
+  background-color: #dc3545;
+  border-radius: 5px;
+}
+
+.blue {
+  background-color: #0d6efd;
+  border-radius: 5px;
+}
diff --git a/scouting/www/shift_schedule/shift_schedule.component.ts b/scouting/www/shift_schedule/shift_schedule.component.ts
new file mode 100644
index 0000000..2f22653
--- /dev/null
+++ b/scouting/www/shift_schedule/shift_schedule.component.ts
@@ -0,0 +1,15 @@
+import {Component, OnInit} from '@angular/core';
+import {Builder, ByteBuffer} from 'flatbuffers';
+import {ErrorResponse} from 'org_frc971/scouting/webserver/requests/messages/error_response_generated';
+
+@Component({
+  selector: 'shift-schedule',
+  templateUrl: './shift_schedule.ng.html',
+  styleUrls: ['../common.css', './shift_schedule.component.css'],
+})
+export class ShiftsComponent {
+  progressMessage: string = '';
+  errorMessage: string = '';
+  // used to calculate shift blocks from starting match to ending match
+  numMatches: number[] = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200];
+}
diff --git a/scouting/www/shift_schedule/shift_schedule.module.ts b/scouting/www/shift_schedule/shift_schedule.module.ts
new file mode 100644
index 0000000..0e5aa48
--- /dev/null
+++ b/scouting/www/shift_schedule/shift_schedule.module.ts
@@ -0,0 +1,12 @@
+import {CommonModule} from '@angular/common';
+import {NgModule} from '@angular/core';
+import {FormsModule} from '@angular/forms';
+
+import {ShiftsComponent} from './shift_schedule.component';
+
+@NgModule({
+  declarations: [ShiftsComponent],
+  exports: [ShiftsComponent],
+  imports: [CommonModule, FormsModule],
+})
+export class ShiftScheduleModule {}
diff --git a/scouting/www/shift_schedule/shift_schedule.ng.html b/scouting/www/shift_schedule/shift_schedule.ng.html
new file mode 100644
index 0000000..3a9cdf0
--- /dev/null
+++ b/scouting/www/shift_schedule/shift_schedule.ng.html
@@ -0,0 +1,33 @@
+<div class="header">
+  <h2>Shift Schedule</h2>
+</div>
+
+<div class="container-fluid">
+  <div class="row">
+    <div *ngFor="let num of numMatches">
+      <span class="badge bg-secondary rounded-left">
+        Scouting matches from {{num-19}} to {{num}}
+      </span>
+      <div class="list-group list-group-horizontal-sm">
+        <div class="redColumn">
+          <div *ngFor="let allianceNum of [1, 2, 3]">
+            <input
+              class="red text-center text-white fw-bold list-group-item list-group-item-action"
+              type="text"
+            />
+          </div>
+        </div>
+        <div class="blueColumn">
+          <div *ngFor="let allianceNum of [1, 2, 3]">
+            <input
+              class="blue text-center text-white fw-bold list-group-item list-group-item-action"
+              type="text"
+            />
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  <button class="btn btn-primary">Save</button>
+  <span class="error_message" role="alert">{{ errorMessage }}</span>
+</div>
diff --git a/scouting/www/view/BUILD b/scouting/www/view/BUILD
new file mode 100644
index 0000000..fae4b23
--- /dev/null
+++ b/scouting/www/view/BUILD
@@ -0,0 +1,27 @@
+load("@npm//@bazel/typescript:index.bzl", "ts_library")
+
+ts_library(
+    name = "view",
+    srcs = [
+        "view.component.ts",
+        "view.module.ts",
+    ],
+    angular_assets = [
+        "view.component.css",
+        "view.ng.html",
+        "//scouting/www:common_css",
+    ],
+    compiler = "//tools:tsc_wrapped_with_angular",
+    target_compatible_with = ["@platforms//cpu:x86_64"],
+    use_angular_plugin = True,
+    visibility = ["//visibility:public"],
+    deps = [
+        "//scouting/webserver/requests/messages:error_response_ts_fbs",
+        "//scouting/webserver/requests/messages:request_all_matches_response_ts_fbs",
+        "//scouting/webserver/requests/messages:request_all_matches_ts_fbs",
+        "@com_github_google_flatbuffers//ts:flatbuffers_ts",
+        "@npm//@angular/common",
+        "@npm//@angular/core",
+        "@npm//@angular/forms",
+    ],
+)
diff --git a/scouting/www/view/view.component.css b/scouting/www/view/view.component.css
new file mode 100644
index 0000000..e220645
--- /dev/null
+++ b/scouting/www/view/view.component.css
@@ -0,0 +1,3 @@
+* {
+  padding: 10px;
+}
diff --git a/scouting/www/view/view.component.ts b/scouting/www/view/view.component.ts
new file mode 100644
index 0000000..8150efd
--- /dev/null
+++ b/scouting/www/view/view.component.ts
@@ -0,0 +1,8 @@
+import {Component, OnInit} from '@angular/core';
+
+@Component({
+  selector: 'app-view',
+  templateUrl: './view.ng.html',
+  styleUrls: ['../common.css', './view.component.css'],
+})
+export class ViewComponent {}
diff --git a/scouting/www/view/view.module.ts b/scouting/www/view/view.module.ts
new file mode 100644
index 0000000..075034e
--- /dev/null
+++ b/scouting/www/view/view.module.ts
@@ -0,0 +1,11 @@
+import {CommonModule} from '@angular/common';
+import {NgModule} from '@angular/core';
+import {FormsModule} from '@angular/forms';
+import {ViewComponent} from './view.component';
+
+@NgModule({
+  declarations: [ViewComponent],
+  exports: [ViewComponent],
+  imports: [CommonModule, FormsModule],
+})
+export class ViewModule {}
diff --git a/scouting/www/view/view.ng.html b/scouting/www/view/view.ng.html
new file mode 100644
index 0000000..b7ed627
--- /dev/null
+++ b/scouting/www/view/view.ng.html
@@ -0,0 +1 @@
+<h2>View Data</h2>
diff --git a/third_party/BUILD b/third_party/BUILD
index 8dbb529..a550a24 100644
--- a/third_party/BUILD
+++ b/third_party/BUILD
@@ -55,6 +55,7 @@
     deps = select({
         "//tools:cpu_k8": ["@gstreamer_k8//:gstreamer"],
         "//tools:cpu_armhf": ["@gstreamer_armhf//:gstreamer"],
+        "//tools:cpu_arm64": ["@gstreamer_arm64//:gstreamer"],
         "//conditions:default": [":unavailable"],
     }),
 )
diff --git a/third_party/allwpilib/hal/src/main/native/athena/PWM.cpp b/third_party/allwpilib/hal/src/main/native/athena/PWM.cpp
index 19a3b83..83a0ca5 100644
--- a/third_party/allwpilib/hal/src/main/native/athena/PWM.cpp
+++ b/third_party/allwpilib/hal/src/main/native/athena/PWM.cpp
@@ -430,6 +430,7 @@
 
 void HAL_SetPWMPeriodScale(HAL_DigitalHandle pwmPortHandle, int32_t squelchMask,
                            int32_t* status) {
+  pwmSystem->writeConfig_Period(5050 / 2, status);
   auto port = digitalChannelHandles->Get(pwmPortHandle, HAL_HandleEnum::PWM);
   if (port == nullptr) {
     *status = HAL_HANDLE_ERROR;
diff --git a/third_party/flatbuffers/build_defs.bzl b/third_party/flatbuffers/build_defs.bzl
index cb50726..7eaa4d3 100644
--- a/third_party/flatbuffers/build_defs.bzl
+++ b/third_party/flatbuffers/build_defs.bzl
@@ -379,7 +379,8 @@
         flatc_args = DEFAULT_FLATC_TS_ARGS,
         visibility = None,
         restricted_to = None,
-        include_reflection = True):
+        include_reflection = True,
+        package_name = None):
     """Generates a ts_library rule for a given flatbuffer definition.
 
     Args:
@@ -401,6 +402,7 @@
       include_reflection: Optional, Whether to depend on the flatbuffer
         reflection library automatically. Only really relevant for the
         target that builds the reflection library itself.
+      package_name: Optional, Package name to use for the generated code.
     """
     srcs_lib = "%s_srcs" % (name)
 
@@ -428,7 +430,7 @@
         "SRCS=($(SRCS));",
         "OUTS=($(OUTS));",
         "for i in $${!SRCS[@]}; do",
-        "sed 's/third_party\\/flatbuffers/external\\/com_github_google_flatbuffers/' $${SRCS[i]} > $${OUTS[i]};",
+        "sed \"s/'.*reflection\\/reflection_pregenerated/'flatbuffers_reflection\\/reflection_generated/\" $${SRCS[i]} > $${OUTS[i]};",
         "sed -i 's/_pregenerated/_generated/' $${OUTS[i]};",
         "done",
     ])
@@ -469,6 +471,7 @@
         restricted_to = restricted_to,
         target_compatible_with = target_compatible_with,
         deps = [name + "_ts"],
+        package_name = package_name,
     )
     native.filegroup(
         name = "%s_includes" % (name),
diff --git a/third_party/flatbuffers/reflection/BUILD.bazel b/third_party/flatbuffers/reflection/BUILD.bazel
index 7948e12..aa421db 100644
--- a/third_party/flatbuffers/reflection/BUILD.bazel
+++ b/third_party/flatbuffers/reflection/BUILD.bazel
@@ -8,6 +8,7 @@
 
 flatbuffer_ts_library(
     name = "reflection_ts_fbs",
+    package_name = "flatbuffers_reflection",
     srcs = ["reflection.fbs"],
     include_reflection = False,
     visibility = ["//visibility:public"],
diff --git a/third_party/rules_rust/.bazelci/presubmit.yml b/third_party/rules_rust/.bazelci/presubmit.yml
new file mode 100644
index 0000000..1e59628
--- /dev/null
+++ b/third_party/rules_rust/.bazelci/presubmit.yml
@@ -0,0 +1,302 @@
+---
+aspects_flags: &aspects_flags
+  - "--config=rustfmt"
+  - "--config=clippy"
+default_linux_targets: &default_linux_targets
+  - "//..."
+  # TODO: Switch manual tag to platform constraint after bazel 4.0.
+  - "//test/versioned_dylib:versioned_dylib_test"
+default_macos_targets: &default_macos_targets
+  - "//..."
+default_windows_targets: &default_windows_targets
+  - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+  - "//..."
+  - "-//bindgen/..."
+  - "-//test/proto/..."
+  - "-//tools/rust_analyzer/..."
+  - "-//test/rustfmt/..."
+crate_universe_vendor_example_targets: &crate_universe_vendor_example_targets
+  - "//vendor_local_manifests:crates_vendor"
+  - "//vendor_local_pkgs:crates_vendor"
+  - "//vendor_remote_manifests:crates_vendor_manifests"
+  - "//vendor_remote_pkgs:crates_vendor_pkgs"
+tasks:
+  ubuntu2004:
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+  rbe_ubuntu1604:
+    shell_commands:
+      - sed -i 's/^# load("@bazelci_rules/load("@bazelci_rules/' WORKSPACE.bazel
+      - sed -i 's/^# rbe_preconfig/rbe_preconfig/' WORKSPACE.bazel
+    build_targets:
+      - "//..."
+    test_targets:
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "//..."
+      - "//test/..."
+      - "-//test/conflicting_deps:conflicting_deps_test"
+  macos:
+    build_targets: *default_macos_targets
+    test_targets: *default_macos_targets
+    build_flags: *aspects_flags
+  windows:
+    build_flags:
+      - "--enable_runfiles" # this is not enabled by default on windows and is necessary for the cargo build scripts
+      - "--config=rustfmt"
+      - "--config=clippy"
+    build_targets: *default_windows_targets
+    test_targets: *default_windows_targets
+  ubuntu2004_with_aspects:
+    name: With Aspects
+    platform: ubuntu2004
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+    build_flags: *aspects_flags
+  rbe_ubuntu1604_with_aspects:
+    name: With Aspects
+    platform: rbe_ubuntu1604
+    shell_commands:
+      - sed -i 's/^# load("@bazelci_rules/load("@bazelci_rules/' WORKSPACE.bazel
+      - sed -i 's/^# rbe_preconfig/rbe_preconfig/' WORKSPACE.bazel
+    build_targets: *default_linux_targets
+    test_targets:
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "..."
+      - "//test/..."
+      - "-//test/conflicting_deps:conflicting_deps_test"
+    build_flags: *aspects_flags
+  rbe_ubuntu1604_rolling_with_aspects:
+    name: RBE Rolling Bazel Version With Aspects
+    platform: rbe_ubuntu1604
+    shell_commands:
+      - sed -i 's/^# load("@bazelci_rules/load("@bazelci_rules/' WORKSPACE.bazel
+      - sed -i 's/^# rbe_preconfig/rbe_preconfig/' WORKSPACE.bazel
+    build_targets: *default_linux_targets
+    test_targets:
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "..."
+      - "//test/..."
+      - "-//test/conflicting_deps:conflicting_deps_test"
+    build_flags: *aspects_flags
+    soft_fail: yes
+    bazel: "rolling"
+  macos_with_aspects:
+    name: With Aspects
+    platform: macos
+    build_targets: *default_macos_targets
+    test_targets: *default_macos_targets
+    build_flags: *aspects_flags
+  macos_rolling_with_aspects:
+    name: "Macos Rolling Bazel Version With Aspects"
+    platform: macos
+    build_targets: *default_macos_targets
+    test_targets: *default_macos_targets
+    build_flags: *aspects_flags
+    soft_fail: yes
+    bazel: "rolling"
+  windows_with_aspects:
+    name: With Aspects
+    platform: windows
+    build_flags:
+      - "--enable_runfiles" # this is not enabled by default on windows and is necessary for the cargo build scripts
+      - "--config=rustfmt"
+      - "--config=clippy"
+    build_targets: *default_windows_targets
+    test_targets: *default_windows_targets
+  windows_rolling_with_aspects:
+    name: "Windows Rolling Bazel Version With Aspects"
+    platform: windows
+    build_flags:
+      - "--enable_runfiles" # this is not enabled by default on windows and is necessary for the cargo build scripts
+      - "--config=rustfmt"
+      - "--config=clippy"
+    build_targets: *default_windows_targets
+    test_targets: *default_windows_targets
+    soft_fail: yes
+    bazel: "rolling"
+  ubuntu2004_clang:
+    name: With Clang
+    platform: ubuntu2004
+    build_flags:
+      - "--config=rustfmt"
+      - "--config=clippy"
+      - "--repo_env=CC=clang"
+      # TODO(hlopko): Make this work (some tests were failing)
+      # - "--linkopt=-fuse-ld=lld"
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+  ubuntu2004_rolling_clang:
+    name: Rolling Bazel Version With Clang
+    platform: ubuntu2004
+    build_flags:
+      - "--config=rustfmt"
+      - "--config=clippy"
+      - "--repo_env=CC=clang"
+      # TODO(hlopko): Make this work (some tests were failing)
+      # - "--linkopt=-fuse-ld=lld"
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+    soft_fail: yes
+    bazel: "rolling"
+  ubuntu1804:
+    name: "Min Bazel Version"
+    bazel: "4.0.0"
+    platform: ubuntu1804
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+  ubuntu1804_with_aspects:
+    name: "Min Bazel Version With Aspects"
+    bazel: "4.0.0"
+    platform: ubuntu1804
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+    build_flags: *aspects_flags
+  ubuntu2004_rolling_with_aspects:
+    name: "Rolling Bazel Version With Aspects"
+    bazel: "rolling"
+    platform: ubuntu2004
+    soft_fail: yes
+    build_targets: *default_linux_targets
+    test_targets: *default_linux_targets
+    build_flags: *aspects_flags
+  linux_docs:
+    name: Docs
+    platform: ubuntu2004
+    working_directory: docs
+    build_targets:
+      - //...
+    run_targets:
+      - "//:test_docs"
+  clippy_failure:
+    name: Negative Clippy Tests
+    platform: ubuntu2004
+    run_targets:
+      - "//test/clippy:clippy_failure_test"
+  rustfmt_failure:
+    name: Negative Rustfmt Tests
+    platform: ubuntu2004
+    run_targets:
+      - "//test/rustfmt:test_runner"
+  rust_analyzer_tests:
+    name: Rust-Analyzer Tests
+    platform: ubuntu2004
+    run_targets:
+      - "//test/rust_analyzer:rust_analyzer_test"
+  ubuntu2004_examples:
+    name: Examples
+    platform: ubuntu2004
+    working_directory: examples
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags: *aspects_flags
+  ubuntu2004_examples_rolling:
+    name: "Examples with Rolling Bazel Version"
+    platform: ubuntu2004
+    working_directory: examples
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags: *aspects_flags
+    soft_fail: yes
+  rbe_ubuntu1604_examples:
+    name: Examples
+    platform: rbe_ubuntu1604
+    working_directory: examples
+    rbe_examples_targets: &rbe_examples_targets
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "//..."
+      # TODO: This requires an updated `rules_foreign_cc`
+      - "-//sys/..."
+      # See https://github.com/bazelbuild/bazel/issues/9987
+      - "-//ffi/rust_calling_c:matrix_dylib_test"
+      # The bindgen rules currently do not work on RBE
+      # see: https://github.com/bazelbuild/rules_rust/issues/919
+      - "-//bindgen/..."
+    shell_commands:
+      - sed -i 's/^# load("@bazelci_rules/load("@bazelci_rules/' WORKSPACE.bazel
+      - sed -i 's/^# rbe_preconfig/rbe_preconfig/' WORKSPACE.bazel
+    build_targets: *rbe_examples_targets
+    test_targets: *rbe_examples_targets
+    build_flags: *aspects_flags
+  macos_examples:
+    name: Examples
+    platform: macos
+    working_directory: examples
+    build_targets:
+      - "//..."
+    test_targets:
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "//..."
+    build_flags: *aspects_flags
+  windows_examples:
+    name: Examples
+    platform: windows
+    working_directory: examples
+    build_flags:
+      - "--enable_runfiles" # this is not enabled by default on windows and is necessary for the cargo build scripts
+      - "--config=rustfmt"
+      - "--config=clippy"
+    windows_targets: &windows_targets
+      - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
+      - "//..."
+      # The bindgen rules currently do not work on windows
+      # see: https://github.com/bazelbuild/rules_rust/issues/919
+      - "-//bindgen/..."
+      # The proto rules do not work on windows
+      - "-//proto/..."
+      # The wasm rules do not work on windows
+      - "-//wasm/..."
+    build_targets: *windows_targets
+    test_targets: *windows_targets
+  crate_universe_examples_ubuntu2004:
+    name: Crate Universe Examples
+    platform: ubuntu2004
+    working_directory: examples/crate_universe
+    run_targets: *crate_universe_vendor_example_targets
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags: *aspects_flags
+  crate_universe_rbe_ubuntu1604:
+    name: Crate Universe Examples
+    platform: rbe_ubuntu1604
+    working_directory: examples/crate_universe
+    shell_commands:
+      - sed -i 's/^# load("@bazelci_rules/load("@bazelci_rules/' WORKSPACE.bazel
+      - sed -i 's/^# rbe_preconfig/rbe_preconfig/' WORKSPACE.bazel
+    run_targets: *crate_universe_vendor_example_targets
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags: *aspects_flags
+  crate_universe_examples_macos:
+    name: Crate Universe Examples
+    platform: macos
+    working_directory: examples/crate_universe
+    run_targets: *crate_universe_vendor_example_targets
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags: *aspects_flags
+  crate_universe_examples_windows:
+    name: Crate Universe Examples
+    platform: windows
+    working_directory: examples/crate_universe
+    batch_commands:
+      - echo startup --windows_enable_symlinks >> user.bazelrc
+      - echo build --enable_runfiles >> user.bazelrc  # this is not enabled by default on windows and is necessary for the cargo build scripts
+    run_targets: *crate_universe_vendor_example_targets
+    build_flags: *aspects_flags
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+buildifier:
+  version: latest
+  warnings: "all"
diff --git a/third_party/rules_rust/.bazelignore b/third_party/rules_rust/.bazelignore
new file mode 100644
index 0000000..2a58041
--- /dev/null
+++ b/third_party/rules_rust/.bazelignore
@@ -0,0 +1,3 @@
+docs
+examples
+crate_universe/private/bootstrap
diff --git a/third_party/rules_rust/.bazelrc b/third_party/rules_rust/.bazelrc
new file mode 100644
index 0000000..dcff4e6
--- /dev/null
+++ b/third_party/rules_rust/.bazelrc
@@ -0,0 +1,17 @@
+# `.bazelrc` is a Bazel configuration file.
+# https://bazel.build/docs/best-practices#bazelrc-file
+
+# Enable rustfmt for all targets in the workspace
+build:rustfmt --aspects=//rust:defs.bzl%rustfmt_aspect
+build:rustfmt --output_groups=+rustfmt_checks
+
+# Enable clippy for all targets in the workspace
+build:clippy --aspects=//rust:defs.bzl%rust_clippy_aspect
+build:clippy --output_groups=+clippy_checks
+
+# https://bazel.build/docs/windows#symlink
+startup --windows_enable_symlinks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/.github/version.bzl.template b/third_party/rules_rust/.github/version.bzl.template
new file mode 100644
index 0000000..b3591a8
--- /dev/null
+++ b/third_party/rules_rust/.github/version.bzl.template
@@ -0,0 +1,8 @@
+"""The version of rules_rust.
+          
+Note: Any change to this file will trigger a new release. To make changes here,
+edit `./.github/version.bzl.template` instead and run the `Release` action to
+create a new release with an updated `./version.bzl` file.
+"""
+
+VERSION = "{VERSION}"
diff --git a/third_party/rules_rust/.github/workflows/release_begin.yaml b/third_party/rules_rust/.github/workflows/release_begin.yaml
new file mode 100644
index 0000000..6313efa
--- /dev/null
+++ b/third_party/rules_rust/.github/workflows/release_begin.yaml
@@ -0,0 +1,197 @@
+---
+name: Release
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "The new version to release"
+        required: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  crate_universe_builds:
+    if: ${{ github.repository_owner == 'bazelbuild' }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        # Create a job for each target triple
+        include:
+          - os: macos-10.15
+            env:
+              TARGET: "aarch64-apple-darwin"
+              EXTENSION: ""
+          - os: ubuntu-20.04
+            env:
+              TARGET: "aarch64-unknown-linux-gnu"
+              EXTENSION: ""
+          - os: macos-10.15
+            env:
+              TARGET: "x86_64-apple-darwin"
+              EXTENSION: ""
+          - os: ubuntu-20.04
+            env:
+              TARGET: "x86_64-pc-windows-gnu"
+              EXTENSION: ".exe"
+          - os: ubuntu-20.04
+            env:
+              TARGET: "x86_64-unknown-linux-gnu"
+              EXTENSION: ""
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: "${{ github.base_ref }}"
+      - run: |
+          # Install cross
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+            curl --fail -Lo ~/cross.tar.gz https://github.com/rust-embedded/cross/releases/download/v0.2.1/cross-v0.2.1-x86_64-apple-darwin.tar.gz
+          else
+            curl --fail -Lo ~/cross.tar.gz https://github.com/rust-embedded/cross/releases/download/v0.2.1/cross-v0.2.1-x86_64-unknown-linux-gnu.tar.gz
+          fi
+          sudo tar -xf ~/cross.tar.gz -C /usr/local/bin/
+          sudo chmod +x /usr/local/bin/cross
+        if: matrix.os != 'windows-2019'
+      - run: |
+          # Install rust toolchains for host
+
+          # Detect the current version of rust
+          version="$(grep 'DEFAULT_RUST_VERSION =' ./rust/private/common.bzl | sed 's/DEFAULT_RUST_VERSION = "//' | sed 's/"//')"
+
+          rustup override set "${version}"
+          rustup update stable && rustup default stable
+      - run: |
+          # Setup macos build tooling
+          sudo xcode-select -s /Applications/Xcode_12.4.app/Contents/Developer/
+
+          # Set SDK environment variables
+          echo "SDKROOT=$(xcrun -sdk macosx11.1 --show-sdk-path)" >> $GITHUB_ENV
+          echo "MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx11.1 --show-sdk-platform-version)" >> $GITHUB_ENV
+        if: matrix.os == 'macOS-10.15'
+      - run: |
+          # Build binaries
+          ./crate_universe/private/bootstrap/build.sh
+        env:
+          TARGET: "${{ matrix.env.TARGET }}"
+      - uses: actions/upload-artifact@v2
+        with:
+          name: "${{ matrix.env.TARGET }}"
+          path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/${{ matrix.env.TARGET }}
+          if-no-files-found: error
+  release:
+    if: ${{ github.repository_owner == 'bazelbuild' }}
+    needs: crate_universe_builds
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: main
+      - run: |
+          # Write new releases file
+          cat ${{ github.workspace }}/.github/version.bzl.template \
+          | sed 's/{VERSION}/${{ github.event.inputs.version }}/' \
+          > ${{ github.workspace }}/version.bzl
+      - run: |
+          # Get release candidate number
+          git fetch origin &> /dev/null
+          num_tags="$(git tag -l | grep "${{ github.event.inputs.version }}" | wc -l | xargs || true)"
+          echo "RELEASE_CANDIDATE_NUMBER=$( echo "${num_tags}" | python3 -c 'import sys; print(int(sys.stdin.read().strip()) + 1)')" >> $GITHUB_ENV
+      - uses: actions/download-artifact@v2
+        with:
+          path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin
+      - run: |
+          # Write new crate_universe defaults.bzl file
+          # Copy the new template
+          cp ${{ github.workspace }}/crate_universe/private/defaults.bzl.template ${{ github.workspace }}/crate_universe/private/defaults.bzl
+
+          # Generate the release URL
+          url="${URL_PREFIX}/crate_universe_resolver-{host_triple}{extension}"
+          sed -i "s|{DEFAULT_URL_TEMPLATE}|${url}|" ${{ github.workspace }}/crate_universe/private/defaults.bzl
+          sed -i "s|{rc}|${RELEASE_CANDIDATE_NUMBER}|" ${{ github.workspace }}/crate_universe/private/defaults.bzl
+
+          # Populate all sha256 values
+          TARGETS=(
+            aarch64-apple-darwin
+            aarch64-unknown-linux-gnu
+            x86_64-apple-darwin
+            x86_64-pc-windows-gnu
+            x86_64-unknown-linux-gnu
+          )
+          for triple in ${TARGETS[@]}; do
+            if [[ "${triple}" == *"windows"* ]]; then
+                bin_name=crate_universe_resolver.exe
+            else
+                bin_name=crate_universe_resolver
+            fi
+            sha256="$(shasum --algorithm 256 ${{ github.workspace }}/crate_universe/private/bootstrap/bin/${triple}/release/${bin_name} | awk '{ print $1 }')"
+            sed -i "s|{${triple}--sha256}|${sha256}|" ${{ github.workspace }}/crate_universe/private/defaults.bzl
+          done
+        env:
+          URL_PREFIX: https://github.com/${{ github.repository_owner }}/rules_rust/releases/download/${{ github.event.inputs.version }}
+      - run: |
+          # Update docs for release
+          SKIP_COMMIT=1 ${{ github.workspace }}/docs/update_docs.sh
+      - uses: actions/create-release@v1
+        id: rules_rust_release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          prerelease: true
+          tag_name: ${{ github.event.inputs.version }}rc-${{ env.RELEASE_CANDIDATE_NUMBER }}
+          release_name: ${{ github.event.inputs.version }}rc-${{ env.RELEASE_CANDIDATE_NUMBER }}
+          body: ${{ github.event.inputs.version }}rc-${{ env.RELEASE_CANDIDATE_NUMBER }}
+          commitish: main
+      # There must be a upload action for each platform triple we create
+      - name: "Upload aarch64-apple-darwin"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-aarch64-apple-darwin
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/aarch64-apple-darwin/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload aarch64-unknown-linux-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-aarch64-unknown-linux-gnu
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/aarch64-unknown-linux-gnu/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-apple-darwin"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-apple-darwin
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-apple-darwin/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-pc-windows-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-pc-windows-gnu.exe
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-pc-windows-gnu/release/crate_universe_resolver.exe
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-unknown-linux-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-unknown-linux-gnu
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-unknown-linux-gnu/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - uses: peter-evans/create-pull-request@v3
+        with:
+          title: Release ${{ github.event.inputs.version }}
+          commit-message: release ${{ github.event.inputs.version }}
+          branch: release/${{ github.event.inputs.version }}
+          delete-branch: true
+          body: Release ${{ github.event.inputs.version }}
diff --git a/third_party/rules_rust/.github/workflows/release_finish.yaml b/third_party/rules_rust/.github/workflows/release_finish.yaml
new file mode 100644
index 0000000..116422e
--- /dev/null
+++ b/third_party/rules_rust/.github/workflows/release_finish.yaml
@@ -0,0 +1,122 @@
+---
+name: Release Finalize
+on:
+  push:
+    branches:
+      - main
+    paths:
+      # Only trigger for new releases
+      - "version.bzl"
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  release:
+    if: ${{ github.repository_owner == 'bazelbuild' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: |
+          # Get current release version
+          git fetch origin &> /dev/null
+          RELEASE_VERSION=$(cat version.bzl | grep VERSION | sed 's/VERSION = "//' | sed 's/"//')
+          echo "RELEASE_VERSION=${RELEASE_VERSION}" >> $GITHUB_ENV
+
+          # Get release candidate number
+          echo "RELEASE_CANDIDATE_NUMBER=$(git tag -l | grep "${RELEASE_VERSION}" | wc -l | xargs || true)" >> $GITHUB_ENV
+      - run: |
+          # Ensure there is at least 1 release candidate in the environment
+          if [[ -z "${RELEASE_CANDIDATE_NUMBER}" ]]; then
+            exit 1
+          elif [[ "${RELEASE_CANDIDATE_NUMBER}" -eq "0" ]]; then
+            exit 1
+          fi
+      - run: |
+          # Download all artifacts from the release candidate
+          TARGETS=(
+            aarch64-apple-darwin
+            aarch64-unknown-linux-gnu
+            x86_64-apple-darwin
+            x86_64-pc-windows-gnu
+            x86_64-unknown-linux-gnu
+          )
+
+          for triple in ${TARGETS[@]}; do
+            if [[ "${triple}" == *"windows"* ]]; then
+                ext=".exe"
+            else
+                ext=""
+            fi
+            resolver="${ARTIFACT_DIR}/${triple}/release/crate_universe_resolver${ext}"
+            mkdir -p "$(dirname "${resolver}")"
+            url="${ARTIFACT_URL}/crate_universe_resolver-${triple}${ext}"
+            echo "Downloading '${url}' to '${resolver}'"
+            curl --fail -Lo "${resolver}" "${url}"
+            sha256="$(shasum --algorithm 256 "${resolver}" | awk '{ print $1 }')"
+
+            if [[ -z "$(grep "\"${triple}\": \"${sha256}\"" ${{ github.workspace }}/crate_universe/private/defaults.bzl)" ]]; then
+              echo "Unexpected sha256 value from `${url}`: got ${sha256}, expected value in `defaults.bzl`"
+              exit 1
+            fi
+          done
+        env:
+          ARTIFACT_URL: https://github.com/${{ github.repository_owner }}/rules_rust/releases/download/${{env.RELEASE_VERSION}}rc-${{ env.RELEASE_CANDIDATE_NUMBER }}
+          ARTIFACT_DIR: ${{ github.workspace }}/crate_universe/private/bootstrap/bin
+      - uses: actions/create-release@v1
+        id: rules_rust_release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          prerelease: true
+          tag_name: ${{env.RELEASE_VERSION}}
+          release_name: ${{env.RELEASE_VERSION}}
+          body: ${{env.RELEASE_VERSION}}
+          commitish: ${{ github.base_ref }}
+      # There must be a upload action for each platform triple we create
+      - name: "Upload aarch64-apple-darwin"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-aarch64-apple-darwin
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/aarch64-apple-darwin/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload aarch64-unknown-linux-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-aarch64-unknown-linux-gnu
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/aarch64-unknown-linux-gnu/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-apple-darwin"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-apple-darwin
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-apple-darwin/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-pc-windows-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-pc-windows-gnu.exe
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-pc-windows-gnu/release/crate_universe_resolver.exe
+          asset_content_type: application/octet-stream
+      - name: "Upload x86_64-unknown-linux-gnu"
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.rules_rust_release.outputs.upload_url }}
+          asset_name: crate_universe_resolver-x86_64-unknown-linux-gnu
+          asset_path: ${{ github.workspace }}/crate_universe/private/bootstrap/bin/x86_64-unknown-linux-gnu/release/crate_universe_resolver
+          asset_content_type: application/octet-stream
diff --git a/third_party/rules_rust/.gitignore b/third_party/rules_rust/.gitignore
new file mode 100644
index 0000000..ca118a2
--- /dev/null
+++ b/third_party/rules_rust/.gitignore
@@ -0,0 +1,30 @@
+# A file specifying filepatterns for git to ignore.
+
+# vim
+*.swp
+
+# bazel
+/bazel-*
+/examples/bazel-*
+/examples/crate_universe/*/bazel-*
+/docs/bazel-*
+user.bazelrc
+
+# rustfmt
+*.rs.bk
+
+# Cargo
+**/target/
+
+# npm
+**/node_modules/
+
+# vscode
+.vscode
+*.code-workspace
+
+# BazelCI
+bazelci.py
+
+# rust-analyzer
+rust-project.json
diff --git a/third_party/rules_rust/ARCHITECTURE.md b/third_party/rules_rust/ARCHITECTURE.md
new file mode 100644
index 0000000..c9a7a09
--- /dev/null
+++ b/third_party/rules_rust/ARCHITECTURE.md
@@ -0,0 +1,58 @@
+# Rules Rust - Architecture
+
+In this file we describe how we think about the architecture
+of `rules_rust`. Its goal is to help contributors orient themselves, and to
+document code restrictions and assumptions.
+
+In general we try to follow the common standard defined by
+https://docs.bazel.build/versions/master/skylark/deploying.html.
+
+## //rust
+
+This is the core package of the rules. It contains all the core rules such as
+`rust_binary` and `rust_library`. It also contains `rust_common`, a Starlark
+struct providing all rules_rust APIs that one might need when writing custom
+rules integrating with rules_rust.
+
+`//rust` and all its subpackages have to be standalone. Users who only need
+the core rules should be able to ignore all other packages.
+
+`//rust:defs.bzl` is the file that all users of `rules_rust` will be using.
+Everything in this file can be used (depended on) and is supported  (though
+stability is not currently guaranteed across commits, see
+[#600](https://github.com/bazelbuild/rules_rust/issues/600)). Typically this
+file re-exports definitions from other files, typically from `//rust/private`.
+Also other packages in `rules_rust` should access core rules through the public
+API only. We expect dogfooding our own APIs increases their
+quality.
+
+`//rust/private` package contains code for rule implementation. This file can only
+depend on `//rust` and its subpackages. Exceptions are Bazel's builtin packages
+and public APIs of other rules (such as `rules_cc`). Depending on
+`//rust/private` from packages other than `//rust` is not supported, we reserve
+the right to change anything there and not tell anybody.
+
+When core rules need custom tools (such as process wrapper, launcher, test
+runner, and so on), they should be stored in `//rust/tools` (for public tools)
+or in `//rust/private/tools` (for private tools). These should:
+
+* be essential (it does not make sense to have core rules without them)
+* have few or no third party dependencies, and their third party dependencies
+    should be checked in.
+* be usable for cross compilation
+* have only essential requirements on the host system (requiring that a custom
+    library is installed on the system is frowned upon)
+
+## //examples (@examples)
+
+Examples package is actually a local repository. This repository can have
+additional dependencies on anything that helps demonstrate an example. Non
+trivial examples should have an accompanying README.md file.
+
+The goal of examples is to demonstrate usage of `rules_rust`, not to test code.
+Use `//test` for testing.
+
+## //test
+
+Contains unit (in `//test/unit`) and integration tests. CI configuration is
+stored in .bazelci.
diff --git a/third_party/rules_rust/AUTHORS b/third_party/rules_rust/AUTHORS
new file mode 100644
index 0000000..15cde4f
--- /dev/null
+++ b/third_party/rules_rust/AUTHORS
@@ -0,0 +1,20 @@
+# This the official list of Bazel authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as:
+# Name or Organization <email address>
+# The email address is not required for organizations.
+
+Google Inc.
+Spotify AB
+VMware Inc.
+Damien Martin-Guillerez <dmarting@google.com>
+David Chen <dzc@google.com>
+Florian Weikert <fwe@google.com>
+Francois-Rene Rideau <tunes@google.com>
+Julio Merino <jmmv@google.com>
+Kamal Marhubi <kamal@marhubi.com>
+Kristina Chodorow <kchodorow@google.com>
+Philipp Wollermann <philwo@google.com>
+Ulf Adams <ulfjack@google.com>
diff --git a/third_party/rules_rust/BUILD.bazel b/third_party/rules_rust/BUILD.bazel
new file mode 100644
index 0000000..598746e
--- /dev/null
+++ b/third_party/rules_rust/BUILD.bazel
@@ -0,0 +1,72 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//rust:defs.bzl", "capture_clippy_output", "error_format", "extra_exec_rustc_flags", "extra_rustc_flags")
+
+exports_files(["LICENSE"])
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = [
+        ":workspace.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//:bzl_lib` target instead",
+    visibility = ["//visibility:public"],
+)
+
+# This setting may be changed from the command line to generate machine readable errors.
+error_format(
+    name = "error_format",
+    build_setting_default = "human",
+    visibility = ["//visibility:public"],
+)
+
+# This setting may be used to pass extra options to rustc from the command line
+# in non-exec configuration.
+# It applies across all targets whereas the rustc_flags option on targets applies only
+# to that target. This can be useful for passing build-wide options such as LTO.
+extra_rustc_flags(
+    name = "extra_rustc_flags",
+    build_setting_default = [],
+    visibility = ["//visibility:public"],
+)
+
+# This setting may be used to pass extra options to rustc from the command line
+# in exec configuration.
+# It applies across all targets whereas the rustc_flags option on targets applies only
+# to that target. This can be useful for passing build-wide options such as LTO.
+extra_exec_rustc_flags(
+    name = "extra_exec_rustc_flags",
+    build_setting_default = [],
+    visibility = ["//visibility:public"],
+)
+
+# This setting is used by the clippy rules. See https://bazelbuild.github.io/rules_rust/rust_clippy.html
+label_flag(
+    name = "clippy.toml",
+    build_setting_default = "//tools/clippy:clippy.toml",
+    visibility = ["//visibility:public"],
+)
+
+# This setting is used by the rustfmt rules. See https://bazelbuild.github.io/rules_rust/rust_fmt.html
+label_flag(
+    name = "rustfmt.toml",
+    build_setting_default = "//tools/rustfmt:rustfmt.toml",
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "rustfmt",
+    actual = "//tools/rustfmt",
+    visibility = ["//visibility:public"],
+)
+
+capture_clippy_output(
+    name = "capture_clippy_output",
+    build_setting_default = False,
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/CODEOWNERS b/third_party/rules_rust/CODEOWNERS
new file mode 100644
index 0000000..e18351f
--- /dev/null
+++ b/third_party/rules_rust/CODEOWNERS
@@ -0,0 +1,2 @@
+# Just for information
+# * @acmcarther @mfarrugi @damienmg @smklein @dfreese
diff --git a/third_party/rules_rust/COMPATIBILITY.md b/third_party/rules_rust/COMPATIBILITY.md
new file mode 100644
index 0000000..afb44bd
--- /dev/null
+++ b/third_party/rules_rust/COMPATIBILITY.md
@@ -0,0 +1,109 @@
+# `rules_rust` backwards compatibility policy
+
+This document defines the backwards compatibility policy for rules_rust and
+defines the process for making compatibility breaking changes. Any exception to
+this process will have to be thoroughly discussed and there will have to be a
+consensus between maintainers that the exception should be granted.
+
+## What is a compatibility breaking change?
+
+A backwards compatible change has the property that a build that is green,
+correct, is using stable APIs of `rules_rust`, and is using a supported version
+of Bazel before the change is still green and correct after the change. In
+practice it means that users should not have to modify their project source
+files, their `BUILD` files, their `bzl` files, their `rust_toolchain`
+definitions, their platform definitions, or their build settings.
+
+A backwards compatible release has the property that it only contains backward
+compatible changes.
+
+`rules_rust` follow [SemVer 2.0.0](https://semver.org/). `rules_rust` promise
+that all minor version number and patch version number releases only contain
+backwards compatible changes.
+
+`rules_rust` don't make any guarantees about compatibility between a released
+version and the state of the `rules_rust` at HEAD.
+
+Backwards incompatible changes will have to follow a process in order to be
+released. Users will be given at least one release where the old behavior is
+still present but deprecated to allow smooth migration of their project to the
+new behavior.
+
+### Compatibility before 1.0
+
+All minor version number releases before version 1.0 can be backwards incompatible.
+Backwards incompatible changes still have to follow the the process, but minimum
+time for migration is reduced to 2 weeks.
+
+## What Bazel versions are supported?
+
+`rules_rust` support the current Bazel LTS at the time of a `rules_rust`
+release.
+
+Support for the current Bazel rolling release is on the best effort basis. If
+the CI build of `rules_rust` against the current Bazel rolling release is green,
+it has to stay green. If the build is already red (because the new Bazel rolling
+release had incompatible changes that broke `rules_rust`), it is acceptable to
+merge PRs leaving the build red as long as the reason for failure remains the
+same. We hope red CI with the current rolling release will be rare.
+
+`rules_rust` don't promise all new `rules_rust` features available to the
+current Bazel rolling release to be be available to the current Bazel LTS
+release (because Bazel compatibility policy doesn't allow us to make that
+promise, and some new features of `rules_rust` require new Bazel features that
+are only available in Bazel rolling releases). `rules_rust` will aim that new
+features available to the current Bazel rolling release will be available to the
+next Bazel LTS release at latest.
+
+Whenever there is a new Bazel LTS release, all releases of `rules_rust` will maintain
+support for the older LTS version for at least 3 months unless Bazel doesn't allow this.
+
+## What host platforms are supported?
+
+Platforms subject to backwards compatibility policy are
+`x86_64-unknown-linux-gnu` and `x86_64-apple-darwin` (platforms supported by `rules_rust`).
+Process for moving a best effort platform to a supported platform is consensus-based.
+
+## What are the stable APIs of `rules_rust`?
+
+`//rust:defs.bzl` is subject to the backwards compatibility policy. That means
+that anything directly accessible from this file is considered stable.
+
+`//rust/private/…` is not subject to the backwards compatibility policy. Content
+of this package is an implementation detail.
+
+`//cargo:cargo_build_script.bzl` is subject to the backwards compatibility policy.
+
+`//cargo`, `//util`, `//tools`, `//test`, `//examples`, `//bindgen`, `//proto`,
+`//wasm_bindgen` and any packages not mentioned by this document are by default
+not subject to the backwards compatibility policy.
+
+Experimental build settings are not subject to the backward compatibility
+policy. They should be added to `//rust:experimental.bzl`.
+
+Incompatible build settings are subject to the backward compatibility policy,
+meaning the behavior of the flag cannot change in a backwards incompatible way.
+They should be added to `//rust:incompatible.bzl`.
+
+Bug fixes are not a breaking change by default. We'll use Common Sense (and we
+will pull in more maintainers and the community to discuss) if we see a certain
+bug fix is controversial. Incompatible changes to
+`//cargo:cargo_build_script.bzl` that make `cargo_build_script` more accurately
+follow cargo's behaviour are considered bug fixes.
+
+## How to make a backwards incompatible change?
+
+1. Create a GitHub issue (example:
+[Split rust_library into smaller rules#591](https://github.com/bazelbuild/rules_rust/issues/591)).
+2. Describe the change, motivation for the change, provide migration
+instructions/tooling.
+3. Add a build setting into `//rust:incompatible.bzl` that removes the old
+behavior (whenever possible) or changes the current behavior (when just
+removing the old behavior is not possible). Ideally, users should not need to
+manually flip incompatible flags.
+4. Mention the link to the GitHub issue in error messages. Do not add a
+deprecation warning (warnings make the deprecation visible to every user
+building a project, not only to the maintainers of the project or the rules).
+5. Mention the issue in the `CHANGELOG` file.
+6. Give the community 3 months from the first release mentioning the issue until
+the flag flip to migrate.
diff --git a/third_party/rules_rust/CONTRIBUTING.md b/third_party/rules_rust/CONTRIBUTING.md
new file mode 100644
index 0000000..9d3d1aa
--- /dev/null
+++ b/third_party/rules_rust/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+**Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual?csw=1)
+(CLA)**, which you can do online.
+
+The CLA is necessary mainly because you own the copyright to your changes,
+even after your contribution becomes part of our codebase, so we need your
+permission to use and distribute your code. We also need to be sure of
+various other things — for instance that you'll tell us if you know that
+your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+
+Before you start working on a larger contribution, you should get in touch
+with us first. Use the issue tracker to explain your idea so we can help and
+possibly guide you.
+
+### Code reviews and other contributions.
+**All submissions, including submissions by project members, require review.**
+Please follow the instructions in [the contributors documentation](http://bazel.io/contributing.html).
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).
diff --git a/third_party/rules_rust/CONTRIBUTORS b/third_party/rules_rust/CONTRIBUTORS
new file mode 100644
index 0000000..d281eeb
--- /dev/null
+++ b/third_party/rules_rust/CONTRIBUTORS
@@ -0,0 +1,23 @@
+# People who have agreed to one of the CLAs and can contribute patches.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# https://developers.google.com/open-source/cla/individual
+# https://developers.google.com/open-source/cla/corporate
+#
+# Names should be added to this file as:
+#     Name <email address>
+
+Damien Martin-Guillerez <dmarting@google.com>
+David Chen <dzc@google.com>
+Florian Weikert <fwe@google.com>
+Francois-Rene Rideau <tunes@google.com>
+Julio Merino <jmmv@google.com>
+Kamal Marhubi <kamal@marhubi.com>
+Kristina Chodorow <kchodorow@google.com>
+Philipp Wollermann <philwo@google.com>
+Ulf Adams <ulfjack@google.com>
+Justine Alexandra Roberts Tunney <jart@google.com>
+John Edmonds <jedmonds@spotify.com>
+Ivan Kalchev <kivan@vmware.com>
diff --git a/third_party/rules_rust/LICENSE.txt b/third_party/rules_rust/LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/third_party/rules_rust/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/third_party/rules_rust/README.md b/third_party/rules_rust/README.md
new file mode 100644
index 0000000..dea4810
--- /dev/null
+++ b/third_party/rules_rust/README.md
@@ -0,0 +1,21 @@
+# Rust Rules
+
+* Postsubmit [![Build status](https://badge.buildkite.com/76523cc666caab9ca91c2a08d9ac8f84af28cb25a92f387293.svg?branch=main)](https://buildkite.com/bazel/rustlang-rules-rust-postsubmit?branch=main)
+
+## Overview
+
+This repository provides rules for building [Rust](https://www.rust-lang.org/) projects with [Bazel](https://bazel.build/).
+
+## Community
+
+General discussions and announcements take place in the [GitHub Discussions](https://github.com/bazelbuild/rules_rust/discussions), but there are
+additional places where community members gather to discuss `rules_rust`.
+
+* Chat: [#rust](https://bazelbuild.slack.com/archives/CSV56UT0F) channel on Bazel Slack: [https://slack.bazel.build/](https://slack.bazel.build/)
+* **Archived** Developer mailing list: [groups.google.com/g/rules_rust](https://groups.google.com/g/rules_rust)
+
+## Documentation
+
+<!-- TODO: Render generated docs on the github pages site again, https://bazelbuild.github.io/rules_rust/ -->
+
+Please refer to [the full documentation](https://bazelbuild.github.io/rules_rust).
diff --git a/third_party/rules_rust/WORKSPACE.bazel b/third_party/rules_rust/WORKSPACE.bazel
new file mode 100644
index 0000000..9610b09
--- /dev/null
+++ b/third_party/rules_rust/WORKSPACE.bazel
@@ -0,0 +1,59 @@
+workspace(name = "rules_rust")
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains(include_rustc_srcs = True)
+
+load("@rules_rust//crate_universe:crates.bzl", "crate_deps_repository")
+
+crate_deps_repository(bootstrap = True)
+
+load("@rules_rust//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+
+load("@rules_rust//proto:transitive_repositories.bzl", "rust_proto_transitive_repositories")
+
+rust_proto_transitive_repositories()
+
+load("@rules_rust//bindgen:repositories.bzl", "rust_bindgen_repositories")
+
+rust_bindgen_repositories()
+
+load("@rules_rust//tools/rust_analyzer:deps.bzl", "rust_analyzer_deps")
+
+rust_analyzer_deps()
+
+load("@rules_rust//util/import:deps.bzl", "import_deps")
+
+import_deps()
+
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+
+load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
+
+bazel_skylib_workspace()
+
+load("//test:deps.bzl", "rules_rust_test_deps")
+
+rules_rust_test_deps()
+
+# --- end stardoc
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "bazelci_rules",
+    sha256 = "eca21884e6f66a88c358e580fd67a6b148d30ab57b1680f62a96c00f9bc6a07e",
+    strip_prefix = "bazelci_rules-1.0.0",
+    url = "https://github.com/bazelbuild/continuous-integration/releases/download/rules-1.0.0/bazelci_rules-1.0.0.tar.gz",
+)
+
+# To run with RBE on Bazel CI, uncomment the following lines.
+#
+# load("@bazelci_rules//:rbe_repo.bzl", "rbe_preconfig")
+# rbe_preconfig(name = "buildkite_config", toolchain = "ubuntu1604-bazel-java8")
diff --git a/third_party/rules_rust/bindgen/BUILD.bazel b/third_party/rules_rust/bindgen/BUILD.bazel
new file mode 100644
index 0000000..8c5426b
--- /dev/null
+++ b/third_party/rules_rust/bindgen/BUILD.bazel
@@ -0,0 +1,41 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//bindgen:bindgen.bzl", "rust_bindgen_toolchain")
+
+package(default_visibility = ["//visibility:public"])
+
+toolchain_type(name = "bindgen_toolchain")
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]) + ["//bindgen/raze:crates.bzl"],
+    deps = ["//rust:bzl_lib"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//bindgen:bzl_lib` target instead",
+)
+
+rust_bindgen_toolchain(
+    name = "default_bindgen_toolchain_impl",
+    bindgen = "//bindgen/raze:cargo_bin_bindgen",
+    clang = select({
+        "//rust/platform:osx": "@bindgen_clang_osx//:clang",
+        "//conditions:default": "@bindgen_clang_linux//:clang",
+    }),
+    libclang = select({
+        "//rust/platform:osx": "@bindgen_clang_osx//:libclang",
+        "//conditions:default": "@bindgen_clang_linux//:libclang",
+    }),
+    libstdcxx = select({
+        "//rust/platform:osx": "@bindgen_clang_osx//:libc++",
+        "//conditions:default": None,
+    }),
+)
+
+toolchain(
+    name = "default_bindgen_toolchain",
+    toolchain = "default_bindgen_toolchain_impl",
+    toolchain_type = "//bindgen:bindgen_toolchain",
+)
diff --git a/third_party/rules_rust/bindgen/README.md b/third_party/rules_rust/bindgen/README.md
new file mode 100644
index 0000000..cc0fcd2
--- /dev/null
+++ b/third_party/rules_rust/bindgen/README.md
@@ -0,0 +1,82 @@
+# Rust Bindgen Rules
+
+<div class="toc">
+  <h2>Rules</h2>
+  <ul>
+    <li><a href="docs/index.md#rust_bindgen_toolchain">rust_bindgen_toolchain</a></li>
+    <li>rust_bindgen</li>
+    <li>rust_bindgen_library</li>
+  </ul>
+</div>
+
+## Overview
+
+These rules are for using [Bindgen][bindgen] to generate [Rust][rust] bindings to C (and some C++) libraries.
+
+[rust]: http://www.rust-lang.org/
+[bindgen]: https://github.com/rust-lang/rust-bindgen
+
+See the [bindgen example](../examples/ffi/rust_calling_c/simple/BUILD.bazel#L9) for a more complete example of use.
+
+### Setup
+
+To use the Rust bindgen rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust bindgen toolchain (in addition to the [rust rules setup](..)):
+
+```python
+load("@rules_rust//bindgen:repositories.bzl", "rust_bindgen_repositories")
+
+rust_bindgen_repositories()
+```
+This makes the default toolchain defined in [`@rules_rust`](./BUILD) available.
+
+[raze]: https://github.com/google/cargo-raze
+
+It will load crate dependencies of bindgen that are generated using
+[cargo raze][raze] inside the rules_rust
+repository. However, using those dependencies might conflict with other uses
+of [cargo raze][raze]. If you need to change
+those dependencies, please see the [dedicated section below](#custom-deps).
+
+For additional information, see the [Bazel toolchains documentation](https://docs.bazel.build/versions/master/toolchains.html).
+
+## <a name="custom-deps">Customizing dependencies
+
+These rules depends on the [`bindgen`](https://crates.io/crates/bindgen) binary crate, and it 
+in turn depends on both a clang binary and the clang library. To obtain these dependencies,
+`rust_bindgen_repositories` imports bindgen and its dependencies using BUILD files generated with
+[`cargo raze`][raze], along with a tarball of clang.
+
+If you want to change the bindgen used, or use [`cargo raze`][raze] in a more
+complex scenario (with more dependencies), you must redefine those
+dependencies.
+
+To do this, once you've imported the needed dependencies (see our
+[Cargo.toml](./raze/Cargo.toml) file to see the default dependencies), you
+need to create your own toolchain. To do so you can create a BUILD
+file with your [`rust_bindgen_toolchain`](../docs/index.md#rust_bindgen_toolchain) definition, for example:
+
+```python
+load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_toolchain")
+
+rust_bindgen_toolchain(
+    name = "bindgen-toolchain-impl",
+    bindgen = "//my/raze:cargo_bin_bindgen",
+    clang = "//my/clang:clang",
+    libclang = "//my/clang:libclang.so",
+    libstdcxx = "//my/cpp:libstdc++",
+)
+
+toolchain(
+    name = "bindgen-toolchain",
+    toolchain = "bindgen-toolchain-impl",
+    toolchain_type = "@rules_rust//bindgen:bindgen_toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:bindgen-toolchain")
+```
diff --git a/third_party/rules_rust/bindgen/bindgen.bzl b/third_party/rules_rust/bindgen/bindgen.bzl
new file mode 100644
index 0000000..a0e93d5
--- /dev/null
+++ b/third_party/rules_rust/bindgen/bindgen.bzl
@@ -0,0 +1,265 @@
+# Copyright 2019 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("//rust:defs.bzl", "rust_library")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:rustc.bzl", "get_linker_and_args")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "find_cc_toolchain", "find_toolchain", "get_preferred_artifact")
+
+# TODO(hlopko): use the more robust logic from rustc.bzl also here, through a reasonable API.
+def _get_libs_for_static_executable(dep):
+    """find the libraries used for linking a static executable.
+
+    Args:
+        dep (Target): A cc_library target.
+
+    Returns:
+        depset: A depset[File]
+    """
+    linker_inputs = dep[CcInfo].linking_context.linker_inputs.to_list()
+    return depset([get_preferred_artifact(lib, use_pic = False) for li in linker_inputs for lib in li.libraries])
+
+def rust_bindgen_library(
+        name,
+        header,
+        cc_lib,
+        bindgen_flags = None,
+        clang_flags = None,
+        rustfmt = True,
+        **kwargs):
+    """Generates a rust source file for `header`, and builds a rust_library.
+
+    Arguments are the same as `rust_bindgen`, and `kwargs` are passed directly to rust_library.
+
+    Args:
+        name (str): A unique name for this target.
+        header (str): The label of the .h file to generate bindings for.
+        cc_lib (str): The label of the cc_library that contains the .h file. This is used to find the transitive includes.
+        bindgen_flags (list, optional): Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.
+        clang_flags (list, optional): Flags to pass directly to the clang executable.
+        rustfmt (bool, optional): Enable or disable running rustfmt on the generated file.
+        **kwargs: Arguments to forward to the underlying `rust_library` rule.
+    """
+
+    tags = kwargs.get("tags") or []
+    if "tags" in kwargs:
+        kwargs.pop("tags")
+
+    deps = kwargs.get("deps") or []
+    if "deps" in kwargs:
+        kwargs.pop("deps")
+
+    rust_bindgen(
+        name = name + "__bindgen",
+        header = header,
+        cc_lib = cc_lib,
+        bindgen_flags = bindgen_flags or [],
+        clang_flags = clang_flags or [],
+        rustfmt = rustfmt,
+        tags = tags,
+    )
+
+    rust_library(
+        name = name,
+        srcs = [name + "__bindgen.rs"],
+        tags = tags + ["__bindgen"],
+        deps = deps + [cc_lib],
+        **kwargs
+    )
+
+def _rust_bindgen_impl(ctx):
+    rust_toolchain = find_toolchain(ctx)
+
+    # nb. We can't grab the cc_library`s direct headers, so a header must be provided.
+    cc_lib = ctx.attr.cc_lib
+    header = ctx.file.header
+    cc_header_list = ctx.attr.cc_lib[CcInfo].compilation_context.headers.to_list()
+    if header not in cc_header_list:
+        fail("Header {} is not in {}'s transitive headers.".format(ctx.attr.header, cc_lib), "header")
+
+    toolchain = ctx.toolchains[Label("//bindgen:bindgen_toolchain")]
+    bindgen_bin = toolchain.bindgen
+    rustfmt_bin = toolchain.rustfmt or rust_toolchain.rustfmt
+    clang_bin = toolchain.clang
+    libclang = toolchain.libclang
+    libstdcxx = toolchain.libstdcxx
+
+    # rustfmt is not where bindgen expects to find it, so we format manually
+    bindgen_args = ["--no-rustfmt-bindings"] + ctx.attr.bindgen_flags
+    clang_args = ctx.attr.clang_flags
+
+    output = ctx.outputs.out
+
+    # libclang should only have 1 output file
+    libclang_dir = _get_libs_for_static_executable(libclang).to_list()[0].dirname
+    include_directories = cc_lib[CcInfo].compilation_context.includes.to_list()
+    quote_include_directories = cc_lib[CcInfo].compilation_context.quote_includes.to_list()
+    system_include_directories = cc_lib[CcInfo].compilation_context.system_includes.to_list()
+
+    # Vanilla usage of bindgen produces formatted output, here we do the same if we have `rustfmt` in our toolchain.
+    if ctx.attr.rustfmt and rustfmt_bin:
+        unformatted_output = ctx.actions.declare_file(output.basename + ".unformatted")
+    else:
+        unformatted_output = output
+
+    args = ctx.actions.args()
+    args.add_all(bindgen_args)
+    args.add(header.path)
+    args.add("--output", unformatted_output.path)
+    args.add("--")
+    args.add_all(include_directories, before_each = "-I")
+    args.add_all(quote_include_directories, before_each = "-iquote")
+    args.add_all(system_include_directories, before_each = "-isystem")
+    args.add_all(clang_args)
+
+    env = {
+        "CLANG_PATH": clang_bin.path,
+        "LIBCLANG_PATH": libclang_dir,
+        "RUST_BACKTRACE": "1",
+    }
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+    _, _, linker_env = get_linker_and_args(ctx, ctx.attr, cc_toolchain, feature_configuration, None)
+    env.update(**linker_env)
+
+    # Set the dynamic linker search path so that clang uses the libstdcxx from the toolchain.
+    # DYLD_LIBRARY_PATH is LD_LIBRARY_PATH on macOS.
+    if libstdcxx:
+        env["LD_LIBRARY_PATH"] = ":".join([f.dirname for f in _get_libs_for_static_executable(libstdcxx).to_list()])
+        env["DYLD_LIBRARY_PATH"] = env["LD_LIBRARY_PATH"]
+
+    ctx.actions.run(
+        executable = bindgen_bin,
+        inputs = depset(
+            [header],
+            transitive = [
+                cc_lib[CcInfo].compilation_context.headers,
+                _get_libs_for_static_executable(libclang),
+            ] + ([
+                _get_libs_for_static_executable(libstdcxx),
+            ] if libstdcxx else []),
+        ),
+        outputs = [unformatted_output],
+        mnemonic = "RustBindgen",
+        progress_message = "Generating bindings for {}..".format(header.path),
+        env = env,
+        arguments = [args],
+        tools = [clang_bin],
+    )
+
+    if ctx.attr.rustfmt and rustfmt_bin:
+        rustfmt_args = ctx.actions.args()
+        rustfmt_args.add("--stdout-file", output.path)
+        rustfmt_args.add("--")
+        rustfmt_args.add(rustfmt_bin.path)
+        rustfmt_args.add("--emit", "stdout")
+        rustfmt_args.add("--quiet")
+        rustfmt_args.add(unformatted_output.path)
+
+        ctx.actions.run(
+            executable = ctx.executable._process_wrapper,
+            inputs = [unformatted_output],
+            outputs = [output],
+            arguments = [rustfmt_args],
+            tools = [rustfmt_bin],
+            mnemonic = "Rustfmt",
+        )
+
+rust_bindgen = rule(
+    doc = "Generates a rust source file from a cc_library and a header.",
+    implementation = _rust_bindgen_impl,
+    attrs = {
+        "bindgen_flags": attr.string_list(
+            doc = "Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.",
+        ),
+        "cc_lib": attr.label(
+            doc = "The cc_library that contains the .h file. This is used to find the transitive includes.",
+            providers = [CcInfo],
+        ),
+        "clang_flags": attr.string_list(
+            doc = "Flags to pass directly to the clang executable.",
+        ),
+        "header": attr.label(
+            doc = "The .h file to generate bindings for.",
+            allow_single_file = True,
+        ),
+        "rustfmt": attr.bool(
+            doc = "Enable or disable running rustfmt on the generated file.",
+            default = True,
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+        "_process_wrapper": attr.label(
+            default = Label("//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+    },
+    outputs = {"out": "%{name}.rs"},
+    fragments = ["cpp"],
+    toolchains = [
+        str(Label("//bindgen:bindgen_toolchain")),
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+)
+
+def _rust_bindgen_toolchain_impl(ctx):
+    return platform_common.ToolchainInfo(
+        bindgen = ctx.executable.bindgen,
+        clang = ctx.executable.clang,
+        libclang = ctx.attr.libclang,
+        libstdcxx = ctx.attr.libstdcxx,
+        rustfmt = ctx.executable.rustfmt,
+    )
+
+rust_bindgen_toolchain = rule(
+    _rust_bindgen_toolchain_impl,
+    doc = "The tools required for the `rust_bindgen` rule.",
+    attrs = {
+        "bindgen": attr.label(
+            doc = "The label of a `bindgen` executable.",
+            executable = True,
+            cfg = "exec",
+        ),
+        "clang": attr.label(
+            doc = "The label of a `clang` executable.",
+            executable = True,
+            cfg = "exec",
+        ),
+        "libclang": attr.label(
+            doc = "A cc_library that provides bindgen's runtime dependency on libclang.",
+            cfg = "exec",
+            providers = [CcInfo],
+        ),
+        "libstdcxx": attr.label(
+            doc = "A cc_library that satisfies libclang's libstdc++ dependency. This is used to make the execution of clang hermetic. If None, system libraries will be used instead.",
+            cfg = "exec",
+            providers = [CcInfo],
+            mandatory = False,
+        ),
+        "rustfmt": attr.label(
+            doc = "The label of a `rustfmt` executable. If this is not provided, falls back to the rust_toolchain rustfmt.",
+            executable = True,
+            cfg = "exec",
+            mandatory = False,
+        ),
+    },
+)
diff --git a/third_party/rules_rust/bindgen/raze/BUILD.bazel b/third_party/rules_rust/bindgen/raze/BUILD.bazel
new file mode 100644
index 0000000..fd7e1e5
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/BUILD.bazel
@@ -0,0 +1,48 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "bindgen",
+    actual = "@rules_rust_bindgen__bindgen__0_58_1//:bindgen",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "cargo_bin_bindgen",
+    actual = "@rules_rust_bindgen__bindgen__0_58_1//:cargo_bin_bindgen",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "libloading",
+    actual = "@rules_rust_bindgen__libloading__0_6_3//:libloading",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/bindgen/raze/Cargo.lock b/third_party/rules_rust/bindgen/raze/Cargo.lock
new file mode 100644
index 0000000..542cee0
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/Cargo.lock
@@ -0,0 +1,354 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.58.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f8523b410d7187a43085e7e064416ea32ded16bd0a4e6fc025e21616d01258f"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "clap",
+ "env_logger",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "which",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+
+[[package]]
+name = "cexpr"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4aedb84272dbe89af497cf81375129abda4fc0a9e7c5d317498c15cc30c0d27"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "853eda514c284c2287f4bf20ae614f8781f40a81d32ecda6e91449304dfe077c"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading 0.7.0",
+]
+
+[[package]]
+name = "clap"
+version = "2.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17392a012ea30ef05a610aa97dfb49496e71c9f676b27879922ea5bdf60d9d3f"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "fake_rules_rust_bindgen_lib"
+version = "0.0.1"
+dependencies = [
+ "bindgen",
+ "libloading 0.6.3",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
+
+[[package]]
+name = "libloading"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2443d8f0478b16759158b2f66d525991a05491138bc05814ef52a250148ef4f9"
+dependencies = [
+ "cfg-if 0.1.10",
+ "winapi",
+]
+
+[[package]]
+name = "libloading"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
+dependencies = [
+ "cfg-if 1.0.0",
+ "winapi",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
+
+[[package]]
+name = "nom"
+version = "5.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
+dependencies = [
+ "memchr",
+ "version_check",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "shlex"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42a568c8f2cd051a4d283bd6eb0343ac214c1b0f1ac19f93e1175b2dee38c73d"
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "which"
+version = "3.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d011071ae14a2f6671d0b74080ae0cd8ebf3a6f8c9589a2cd45f23126fe29724"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/bindgen/raze/Cargo.toml b/third_party/rules_rust/bindgen/raze/Cargo.toml
new file mode 100644
index 0000000..2d9129c
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "fake_rules_rust_bindgen_lib"
+version = "0.0.1"
+
+[lib]
+path = "fake_rules_rust_bindgen_lib.rs"
+
+[dependencies]
+bindgen = "0.58.1"
+libloading = "=0.6.3"
+
+[package.metadata.raze]
+genmode = "Remote"
+workspace_path = "//bindgen/raze"
+gen_workspace_prefix = "rules_rust_bindgen"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "."
+default_gen_buildrs = false
+
+[package.metadata.raze.crates.bindgen.'0.58.1']
+gen_buildrs = true
+extra_aliased_targets = ["cargo_bin_bindgen"]
+
+[package.metadata.raze.crates.clang-sys.'1.0.0']
+gen_buildrs = true
+
+[package.metadata.raze.crates.libloading.'0.6.3']
+gen_buildrs = true
+
+[package.metadata.raze.crates.log.'0.4.11']
+additional_flags = [
+    "--cfg=atomic_cas",
+]
diff --git a/third_party/rules_rust/bindgen/raze/crates.bzl b/third_party/rules_rust/bindgen/raze/crates.bzl
new file mode 100644
index 0000000..7cda777
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/crates.bzl
@@ -0,0 +1,422 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def rules_rust_bindgen_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__aho_corasick__0_7_18",
+        url = "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+        type = "tar.gz",
+        sha256 = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f",
+        strip_prefix = "aho-corasick-0.7.18",
+        build_file = Label("//bindgen/raze/remote:BUILD.aho-corasick-0.7.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__ansi_term__0_11_0",
+        url = "https://crates.io/api/v1/crates/ansi_term/0.11.0/download",
+        type = "tar.gz",
+        sha256 = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b",
+        strip_prefix = "ansi_term-0.11.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.ansi_term-0.11.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__atty__0_2_14",
+        url = "https://crates.io/api/v1/crates/atty/0.2.14/download",
+        type = "tar.gz",
+        sha256 = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8",
+        strip_prefix = "atty-0.2.14",
+        build_file = Label("//bindgen/raze/remote:BUILD.atty-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__bindgen__0_58_1",
+        url = "https://crates.io/api/v1/crates/bindgen/0.58.1/download",
+        type = "tar.gz",
+        sha256 = "0f8523b410d7187a43085e7e064416ea32ded16bd0a4e6fc025e21616d01258f",
+        strip_prefix = "bindgen-0.58.1",
+        build_file = Label("//bindgen/raze/remote:BUILD.bindgen-0.58.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__bitflags__1_2_1",
+        url = "https://crates.io/api/v1/crates/bitflags/1.2.1/download",
+        type = "tar.gz",
+        sha256 = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693",
+        strip_prefix = "bitflags-1.2.1",
+        build_file = Label("//bindgen/raze/remote:BUILD.bitflags-1.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__cexpr__0_4_0",
+        url = "https://crates.io/api/v1/crates/cexpr/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "f4aedb84272dbe89af497cf81375129abda4fc0a9e7c5d317498c15cc30c0d27",
+        strip_prefix = "cexpr-0.4.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.cexpr-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__cfg_if__0_1_10",
+        url = "https://crates.io/api/v1/crates/cfg-if/0.1.10/download",
+        type = "tar.gz",
+        sha256 = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822",
+        strip_prefix = "cfg-if-0.1.10",
+        build_file = Label("//bindgen/raze/remote:BUILD.cfg-if-0.1.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__cfg_if__1_0_0",
+        url = "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__clang_sys__1_2_0",
+        url = "https://crates.io/api/v1/crates/clang-sys/1.2.0/download",
+        type = "tar.gz",
+        sha256 = "853eda514c284c2287f4bf20ae614f8781f40a81d32ecda6e91449304dfe077c",
+        strip_prefix = "clang-sys-1.2.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.clang-sys-1.2.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__clap__2_33_3",
+        url = "https://crates.io/api/v1/crates/clap/2.33.3/download",
+        type = "tar.gz",
+        sha256 = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002",
+        strip_prefix = "clap-2.33.3",
+        build_file = Label("//bindgen/raze/remote:BUILD.clap-2.33.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__env_logger__0_8_3",
+        url = "https://crates.io/api/v1/crates/env_logger/0.8.3/download",
+        type = "tar.gz",
+        sha256 = "17392a012ea30ef05a610aa97dfb49496e71c9f676b27879922ea5bdf60d9d3f",
+        strip_prefix = "env_logger-0.8.3",
+        build_file = Label("//bindgen/raze/remote:BUILD.env_logger-0.8.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__glob__0_3_0",
+        url = "https://crates.io/api/v1/crates/glob/0.3.0/download",
+        type = "tar.gz",
+        sha256 = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574",
+        strip_prefix = "glob-0.3.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.glob-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__hermit_abi__0_1_18",
+        url = "https://crates.io/api/v1/crates/hermit-abi/0.1.18/download",
+        type = "tar.gz",
+        sha256 = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c",
+        strip_prefix = "hermit-abi-0.1.18",
+        build_file = Label("//bindgen/raze/remote:BUILD.hermit-abi-0.1.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__humantime__2_1_0",
+        url = "https://crates.io/api/v1/crates/humantime/2.1.0/download",
+        type = "tar.gz",
+        sha256 = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4",
+        strip_prefix = "humantime-2.1.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.humantime-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__lazycell__1_3_0",
+        url = "https://crates.io/api/v1/crates/lazycell/1.3.0/download",
+        type = "tar.gz",
+        sha256 = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55",
+        strip_prefix = "lazycell-1.3.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.lazycell-1.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__libc__0_2_94",
+        url = "https://crates.io/api/v1/crates/libc/0.2.94/download",
+        type = "tar.gz",
+        sha256 = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e",
+        strip_prefix = "libc-0.2.94",
+        build_file = Label("//bindgen/raze/remote:BUILD.libc-0.2.94.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__libloading__0_6_3",
+        url = "https://crates.io/api/v1/crates/libloading/0.6.3/download",
+        type = "tar.gz",
+        sha256 = "2443d8f0478b16759158b2f66d525991a05491138bc05814ef52a250148ef4f9",
+        strip_prefix = "libloading-0.6.3",
+        build_file = Label("//bindgen/raze/remote:BUILD.libloading-0.6.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__libloading__0_7_0",
+        url = "https://crates.io/api/v1/crates/libloading/0.7.0/download",
+        type = "tar.gz",
+        sha256 = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a",
+        strip_prefix = "libloading-0.7.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.libloading-0.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__log__0_4_14",
+        url = "https://crates.io/api/v1/crates/log/0.4.14/download",
+        type = "tar.gz",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        strip_prefix = "log-0.4.14",
+        build_file = Label("//bindgen/raze/remote:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__memchr__2_4_0",
+        url = "https://crates.io/api/v1/crates/memchr/2.4.0/download",
+        type = "tar.gz",
+        sha256 = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc",
+        strip_prefix = "memchr-2.4.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.memchr-2.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__nom__5_1_2",
+        url = "https://crates.io/api/v1/crates/nom/5.1.2/download",
+        type = "tar.gz",
+        sha256 = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af",
+        strip_prefix = "nom-5.1.2",
+        build_file = Label("//bindgen/raze/remote:BUILD.nom-5.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__peeking_take_while__0_1_2",
+        url = "https://crates.io/api/v1/crates/peeking_take_while/0.1.2/download",
+        type = "tar.gz",
+        sha256 = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099",
+        strip_prefix = "peeking_take_while-0.1.2",
+        build_file = Label("//bindgen/raze/remote:BUILD.peeking_take_while-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__proc_macro2__1_0_26",
+        url = "https://crates.io/api/v1/crates/proc-macro2/1.0.26/download",
+        type = "tar.gz",
+        sha256 = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec",
+        strip_prefix = "proc-macro2-1.0.26",
+        build_file = Label("//bindgen/raze/remote:BUILD.proc-macro2-1.0.26.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__quote__1_0_9",
+        url = "https://crates.io/api/v1/crates/quote/1.0.9/download",
+        type = "tar.gz",
+        sha256 = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7",
+        strip_prefix = "quote-1.0.9",
+        build_file = Label("//bindgen/raze/remote:BUILD.quote-1.0.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__regex__1_5_4",
+        url = "https://crates.io/api/v1/crates/regex/1.5.4/download",
+        type = "tar.gz",
+        sha256 = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461",
+        strip_prefix = "regex-1.5.4",
+        build_file = Label("//bindgen/raze/remote:BUILD.regex-1.5.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__regex_syntax__0_6_25",
+        url = "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+        type = "tar.gz",
+        sha256 = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b",
+        strip_prefix = "regex-syntax-0.6.25",
+        build_file = Label("//bindgen/raze/remote:BUILD.regex-syntax-0.6.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__rustc_hash__1_1_0",
+        url = "https://crates.io/api/v1/crates/rustc-hash/1.1.0/download",
+        type = "tar.gz",
+        sha256 = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2",
+        strip_prefix = "rustc-hash-1.1.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.rustc-hash-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__shlex__1_0_0",
+        url = "https://crates.io/api/v1/crates/shlex/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "42a568c8f2cd051a4d283bd6eb0343ac214c1b0f1ac19f93e1175b2dee38c73d",
+        strip_prefix = "shlex-1.0.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.shlex-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__strsim__0_8_0",
+        url = "https://crates.io/api/v1/crates/strsim/0.8.0/download",
+        type = "tar.gz",
+        sha256 = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a",
+        strip_prefix = "strsim-0.8.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.strsim-0.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__termcolor__1_1_2",
+        url = "https://crates.io/api/v1/crates/termcolor/1.1.2/download",
+        type = "tar.gz",
+        sha256 = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4",
+        strip_prefix = "termcolor-1.1.2",
+        build_file = Label("//bindgen/raze/remote:BUILD.termcolor-1.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__textwrap__0_11_0",
+        url = "https://crates.io/api/v1/crates/textwrap/0.11.0/download",
+        type = "tar.gz",
+        sha256 = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060",
+        strip_prefix = "textwrap-0.11.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.textwrap-0.11.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__unicode_width__0_1_8",
+        url = "https://crates.io/api/v1/crates/unicode-width/0.1.8/download",
+        type = "tar.gz",
+        sha256 = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3",
+        strip_prefix = "unicode-width-0.1.8",
+        build_file = Label("//bindgen/raze/remote:BUILD.unicode-width-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__unicode_xid__0_2_2",
+        url = "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+        type = "tar.gz",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("//bindgen/raze/remote:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__vec_map__0_8_2",
+        url = "https://crates.io/api/v1/crates/vec_map/0.8.2/download",
+        type = "tar.gz",
+        sha256 = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191",
+        strip_prefix = "vec_map-0.8.2",
+        build_file = Label("//bindgen/raze/remote:BUILD.vec_map-0.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__version_check__0_9_3",
+        url = "https://crates.io/api/v1/crates/version_check/0.9.3/download",
+        type = "tar.gz",
+        sha256 = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe",
+        strip_prefix = "version_check-0.9.3",
+        build_file = Label("//bindgen/raze/remote:BUILD.version_check-0.9.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__which__3_1_1",
+        url = "https://crates.io/api/v1/crates/which/3.1.1/download",
+        type = "tar.gz",
+        sha256 = "d011071ae14a2f6671d0b74080ae0cd8ebf3a6f8c9589a2cd45f23126fe29724",
+        strip_prefix = "which-3.1.1",
+        build_file = Label("//bindgen/raze/remote:BUILD.which-3.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__winapi__0_3_9",
+        url = "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+        type = "tar.gz",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("//bindgen/raze/remote:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__winapi_i686_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__winapi_util__0_1_5",
+        url = "https://crates.io/api/v1/crates/winapi-util/0.1.5/download",
+        type = "tar.gz",
+        sha256 = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178",
+        strip_prefix = "winapi-util-0.1.5",
+        build_file = Label("//bindgen/raze/remote:BUILD.winapi-util-0.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_bindgen__winapi_x86_64_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("//bindgen/raze/remote:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel
new file mode 100644
index 0000000..f1f73b7
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "aho_corasick",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__memchr__2_4_0//:memchr",
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.ansi_term-0.11.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.ansi_term-0.11.0.bazel
new file mode 100644
index 0000000..9a688a3
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.ansi_term-0.11.0.bazel
@@ -0,0 +1,66 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "colours" with type "example" omitted
+
+rust_library(
+    name = "ansi_term",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.11.0",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(target_os = "windows")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.atty-0.2.14.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.atty-0.2.14.bazel
new file mode 100644
index 0000000..6ccea85
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.atty-0.2.14.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "atty" with type "example" omitted
+
+rust_library(
+    name = "atty",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.14",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_bindgen__libc__0_2_94//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.bindgen-0.58.1.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.bindgen-0.58.1.bazel
new file mode 100644
index 0000000..38fc5b1
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.bindgen-0.58.1.bazel
@@ -0,0 +1,163 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # BSD-3-Clause from expression "BSD-3-Clause"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "bindgen_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "clap",
+        "default",
+        "env_logger",
+        "log",
+        "logging",
+        "runtime",
+        "which",
+        "which-rustfmt",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.58.1",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_bindgen__clang_sys__1_2_0//:clang_sys",
+    ],
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_bindgen",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clap",
+        "default",
+        "env_logger",
+        "log",
+        "logging",
+        "runtime",
+        "which",
+        "which-rustfmt",
+    ],
+    crate_root = "src/main.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.58.1",
+    # buildifier: leave-alone
+    deps = [
+        ":bindgen",
+        ":bindgen_build_script",
+        "@rules_rust_bindgen__bitflags__1_2_1//:bitflags",
+        "@rules_rust_bindgen__cexpr__0_4_0//:cexpr",
+        "@rules_rust_bindgen__clang_sys__1_2_0//:clang_sys",
+        "@rules_rust_bindgen__clap__2_33_3//:clap",
+        "@rules_rust_bindgen__env_logger__0_8_3//:env_logger",
+        "@rules_rust_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_bindgen__lazycell__1_3_0//:lazycell",
+        "@rules_rust_bindgen__log__0_4_14//:log",
+        "@rules_rust_bindgen__peeking_take_while__0_1_2//:peeking_take_while",
+        "@rules_rust_bindgen__proc_macro2__1_0_26//:proc_macro2",
+        "@rules_rust_bindgen__quote__1_0_9//:quote",
+        "@rules_rust_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_bindgen__rustc_hash__1_1_0//:rustc_hash",
+        "@rules_rust_bindgen__shlex__1_0_0//:shlex",
+        "@rules_rust_bindgen__which__3_1_1//:which",
+    ],
+)
+
+rust_library(
+    name = "bindgen",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clap",
+        "default",
+        "env_logger",
+        "log",
+        "logging",
+        "runtime",
+        "which",
+        "which-rustfmt",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.58.1",
+    # buildifier: leave-alone
+    deps = [
+        ":bindgen_build_script",
+        "@rules_rust_bindgen__bitflags__1_2_1//:bitflags",
+        "@rules_rust_bindgen__cexpr__0_4_0//:cexpr",
+        "@rules_rust_bindgen__clang_sys__1_2_0//:clang_sys",
+        "@rules_rust_bindgen__clap__2_33_3//:clap",
+        "@rules_rust_bindgen__env_logger__0_8_3//:env_logger",
+        "@rules_rust_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_bindgen__lazycell__1_3_0//:lazycell",
+        "@rules_rust_bindgen__log__0_4_14//:log",
+        "@rules_rust_bindgen__peeking_take_while__0_1_2//:peeking_take_while",
+        "@rules_rust_bindgen__proc_macro2__1_0_26//:proc_macro2",
+        "@rules_rust_bindgen__quote__1_0_9//:quote",
+        "@rules_rust_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_bindgen__rustc_hash__1_1_0//:rustc_hash",
+        "@rules_rust_bindgen__shlex__1_0_0//:shlex",
+        "@rules_rust_bindgen__which__3_1_1//:which",
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.bitflags-1.2.1.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.bitflags-1.2.1.bazel
new file mode 100644
index 0000000..ee5df63
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.bitflags-1.2.1.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.cexpr-0.4.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.cexpr-0.4.0.bazel
new file mode 100644
index 0000000..d2f0fb5
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.cexpr-0.4.0.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cexpr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__nom__5_1_2//:nom",
+    ],
+)
+
+# Unsupported target "clang" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-0.1.10.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-0.1.10.bazel
new file mode 100644
index 0000000..0d5ec5b
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-0.1.10.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.10",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..9f57c52
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.clang-sys-1.2.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.clang-sys-1.2.0.bazel
new file mode 100644
index 0000000..2c29ee0
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.clang-sys-1.2.0.bazel
@@ -0,0 +1,110 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "clang_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "clang_3_5",
+        "clang_3_6",
+        "clang_3_7",
+        "clang_3_8",
+        "clang_3_9",
+        "clang_4_0",
+        "clang_5_0",
+        "clang_6_0",
+        "libloading",
+        "runtime",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    links = "clang",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.0",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_bindgen__glob__0_3_0//:glob",
+    ],
+)
+
+rust_library(
+    name = "clang_sys",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clang_3_5",
+        "clang_3_6",
+        "clang_3_7",
+        "clang_3_8",
+        "clang_3_9",
+        "clang_4_0",
+        "clang_5_0",
+        "clang_6_0",
+        "libloading",
+        "runtime",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.0",
+    # buildifier: leave-alone
+    deps = [
+        ":clang_sys_build_script",
+        "@rules_rust_bindgen__glob__0_3_0//:glob",
+        "@rules_rust_bindgen__libc__0_2_94//:libc",
+        "@rules_rust_bindgen__libloading__0_7_0//:libloading",
+    ],
+)
+
+# Unsupported target "lib" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.clap-2.33.3.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.clap-2.33.3.bazel
new file mode 100644
index 0000000..7a970d7
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.clap-2.33.3.bazel
@@ -0,0 +1,93 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "clap",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "ansi_term",
+        "atty",
+        "color",
+        "default",
+        "strsim",
+        "suggestions",
+        "vec_map",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.33.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__atty__0_2_14//:atty",
+        "@rules_rust_bindgen__bitflags__1_2_1//:bitflags",
+        "@rules_rust_bindgen__strsim__0_8_0//:strsim",
+        "@rules_rust_bindgen__textwrap__0_11_0//:textwrap",
+        "@rules_rust_bindgen__unicode_width__0_1_8//:unicode_width",
+        "@rules_rust_bindgen__vec_map__0_8_2//:vec_map",
+    ] + selects.with_or({
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_bindgen__ansi_term__0_11_0//:ansi_term",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.env_logger-0.8.3.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.env_logger-0.8.3.bazel
new file mode 100644
index 0000000..6cdc461
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.env_logger-0.8.3.bazel
@@ -0,0 +1,71 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "env_logger",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "atty",
+        "default",
+        "humantime",
+        "regex",
+        "termcolor",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__atty__0_2_14//:atty",
+        "@rules_rust_bindgen__humantime__2_1_0//:humantime",
+        "@rules_rust_bindgen__log__0_4_14//:log",
+        "@rules_rust_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_bindgen__termcolor__1_1_2//:termcolor",
+    ],
+)
+
+# Unsupported target "init-twice-retains-filter" with type "test" omitted
+
+# Unsupported target "log-in-log" with type "test" omitted
+
+# Unsupported target "log_tls_dtors" with type "test" omitted
+
+# Unsupported target "regexp_filter" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.glob-0.3.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.glob-0.3.0.bazel
new file mode 100644
index 0000000..93a10df
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.glob-0.3.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "glob",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "glob-std" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.hermit-abi-0.1.18.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.hermit-abi-0.1.18.bazel
new file mode 100644
index 0000000..211d229
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.hermit-abi-0.1.18.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__libc__0_2_94//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.humantime-2.1.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.humantime-2.1.0.bazel
new file mode 100644
index 0000000..de730f2
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.humantime-2.1.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "datetime_format" with type "bench" omitted
+
+# Unsupported target "datetime_parse" with type "bench" omitted
+
+rust_library(
+    name = "humantime",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..a90e095
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.lazycell-1.3.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.lazycell-1.3.0.bazel
new file mode 100644
index 0000000..5971cb4
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.lazycell-1.3.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazycell",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.3.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.libc-0.2.94.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.libc-0.2.94.bazel
new file mode 100644
index 0000000..2ca1b9e
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.libc-0.2.94.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.94",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.6.3.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.6.3.bazel
new file mode 100644
index 0000000..47b6906
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.6.3.bazel
@@ -0,0 +1,157 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # ISC from expression "ISC"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libloading_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.3",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "libloading",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.3",
+    # buildifier: leave-alone
+    deps = [
+        ":libloading_build_script",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_bindgen__cfg_if__0_1_10//:cfg_if",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "constants" with type "test" omitted
+
+# Unsupported target "functions" with type "test" omitted
+
+# Unsupported target "library_filename" with type "test" omitted
+
+# Unsupported target "markers" with type "test" omitted
+
+# Unsupported target "windows" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.7.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.7.0.bazel
new file mode 100644
index 0000000..5612156
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.libloading-0.7.0.bazel
@@ -0,0 +1,97 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # ISC from expression "ISC"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "libloading",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.0",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_bindgen__cfg_if__1_0_0//:cfg_if",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "constants" with type "test" omitted
+
+# Unsupported target "functions" with type "test" omitted
+
+# Unsupported target "library_filename" with type "test" omitted
+
+# Unsupported target "markers" with type "test" omitted
+
+# Unsupported target "windows" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.log-0.4.14.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..fc3a7e2
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.log-0.4.14.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "value" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=atomic_cas",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
+
+# Unsupported target "macros" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.memchr-2.4.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.memchr-2.4.0.bazel
new file mode 100644
index 0000000..bf5b58d
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.memchr-2.4.0.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "memchr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.nom-5.1.2.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.nom-5.1.2.bazel
new file mode 100644
index 0000000..dbcdd50
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.nom-5.1.2.bazel
@@ -0,0 +1,112 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "arithmetic" with type "bench" omitted
+
+# Unsupported target "http" with type "bench" omitted
+
+# Unsupported target "ini" with type "bench" omitted
+
+# Unsupported target "ini_complete" with type "bench" omitted
+
+# Unsupported target "ini_str" with type "bench" omitted
+
+# Unsupported target "json" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+# Unsupported target "json" with type "example" omitted
+
+# Unsupported target "s_expression" with type "example" omitted
+
+# Unsupported target "string" with type "example" omitted
+
+rust_library(
+    name = "nom",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "5.1.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__memchr__2_4_0//:memchr",
+    ],
+)
+
+# Unsupported target "arithmetic" with type "test" omitted
+
+# Unsupported target "arithmetic_ast" with type "test" omitted
+
+# Unsupported target "blockbuf-arithmetic" with type "test" omitted
+
+# Unsupported target "css" with type "test" omitted
+
+# Unsupported target "custom_errors" with type "test" omitted
+
+# Unsupported target "escaped" with type "test" omitted
+
+# Unsupported target "float" with type "test" omitted
+
+# Unsupported target "inference" with type "test" omitted
+
+# Unsupported target "ini" with type "test" omitted
+
+# Unsupported target "ini_str" with type "test" omitted
+
+# Unsupported target "issues" with type "test" omitted
+
+# Unsupported target "json" with type "test" omitted
+
+# Unsupported target "mp4" with type "test" omitted
+
+# Unsupported target "multiline" with type "test" omitted
+
+# Unsupported target "named_args" with type "test" omitted
+
+# Unsupported target "overflow" with type "test" omitted
+
+# Unsupported target "reborrow_fold" with type "test" omitted
+
+# Unsupported target "test1" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.peeking_take_while-0.1.2.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.peeking_take_while-0.1.2.bazel
new file mode 100644
index 0000000..78249fd
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.peeking_take_while-0.1.2.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "peeking_take_while",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.proc-macro2-1.0.26.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.proc-macro2-1.0.26.bazel
new file mode 100644
index 0000000..d0858e0
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.proc-macro2-1.0.26.bazel
@@ -0,0 +1,66 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.26",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "comments" with type "test" omitted
+
+# Unsupported target "features" with type "test" omitted
+
+# Unsupported target "marker" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.quote-1.0.9.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.quote-1.0.9.bazel
new file mode 100644
index 0000000..a1b8dc2
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.quote-1.0.9.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "quote",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.9",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__proc_macro2__1_0_26//:proc_macro2",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-1.5.4.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-1.5.4.bazel
new file mode 100644
index 0000000..4eddae8
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-1.5.4.bazel
@@ -0,0 +1,102 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "shootout-regex-dna" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-bytes" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-cheat" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-replace" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single-cheat" with type "example" omitted
+
+rust_library(
+    name = "regex",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "aho-corasick",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__aho_corasick__0_7_18//:aho_corasick",
+        "@rules_rust_bindgen__memchr__2_4_0//:memchr",
+        "@rules_rust_bindgen__regex_syntax__0_6_25//:regex_syntax",
+    ],
+)
+
+# Unsupported target "backtrack" with type "test" omitted
+
+# Unsupported target "backtrack-bytes" with type "test" omitted
+
+# Unsupported target "backtrack-utf8bytes" with type "test" omitted
+
+# Unsupported target "crates-regex" with type "test" omitted
+
+# Unsupported target "default" with type "test" omitted
+
+# Unsupported target "default-bytes" with type "test" omitted
+
+# Unsupported target "nfa" with type "test" omitted
+
+# Unsupported target "nfa-bytes" with type "test" omitted
+
+# Unsupported target "nfa-utf8bytes" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel
new file mode 100644
index 0000000..b185ef3
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "regex_syntax",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.25",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.rustc-hash-1.1.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.rustc-hash-1.1.0.bazel
new file mode 100644
index 0000000..e751942
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.rustc-hash-1.1.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rustc_hash",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.shlex-1.0.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.shlex-1.0.0.bazel
new file mode 100644
index 0000000..3b11348
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.shlex-1.0.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "shlex",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.strsim-0.8.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.strsim-0.8.0.bazel
new file mode 100644
index 0000000..a1becf3
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.strsim-0.8.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+rust_library(
+    name = "strsim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "lib" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel
new file mode 100644
index 0000000..ff23f3f
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "termcolor",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.2",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi_util__0_1_5//:winapi_util",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.textwrap-0.11.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.textwrap-0.11.0.bazel
new file mode 100644
index 0000000..541cff5
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.textwrap-0.11.0.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "linear" with type "bench" omitted
+
+# Unsupported target "layout" with type "example" omitted
+
+# Unsupported target "termwidth" with type "example" omitted
+
+rust_library(
+    name = "textwrap",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.11.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__unicode_width__0_1_8//:unicode_width",
+    ],
+)
+
+# Unsupported target "version-numbers" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-width-0.1.8.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-width-0.1.8.bazel
new file mode 100644
index 0000000..ee3ab94
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-width-0.1.8.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "unicode_width",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..bd9e2a7
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "xid" with type "bench" omitted
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "exhaustive_tests" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.vec_map-0.8.2.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.vec_map-0.8.2.bazel
new file mode 100644
index 0000000..031dc5e
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.vec_map-0.8.2.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "vec_map",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.version_check-0.9.3.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.version_check-0.9.3.bazel
new file mode 100644
index 0000000..74a457d
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.version_check-0.9.3.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "version_check",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.which-3.1.1.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.which-3.1.1.bazel
new file mode 100644
index 0000000..15a73c6
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.which-3.1.1.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "which",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "3.1.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_bindgen__libc__0_2_94//:libc",
+    ],
+)
+
+# Unsupported target "basic" with type "test" omitted
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..6fa8b8c
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,67 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "libloaderapi",
+        "minwinbase",
+        "minwindef",
+        "processenv",
+        "std",
+        "winbase",
+        "wincon",
+        "winerror",
+        "winnt",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..7de7c44
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel
new file mode 100644
index 0000000..00689f0
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "winapi_util",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.5",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..747aabe
--- /dev/null
+++ b/third_party/rules_rust/bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/bindgen/repositories.bzl b/third_party/rules_rust/bindgen/repositories.bzl
new file mode 100644
index 0000000..f8614ba
--- /dev/null
+++ b/third_party/rules_rust/bindgen/repositories.bzl
@@ -0,0 +1,90 @@
+# Copyright 2019 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//bindgen/raze:crates.bzl", "rules_rust_bindgen_fetch_remote_crates")
+
+# buildifier: disable=unnamed-macro
+def rust_bindgen_repositories():
+    """Declare dependencies needed for bindgen."""
+
+    # nb. The bindgen rule itself should work on any platform.
+    _bindgen_clang_repositories()
+
+    rules_rust_bindgen_fetch_remote_crates()
+
+    native.register_toolchains(str(Label("//bindgen:default_bindgen_toolchain")))
+
+_COMMON_WORKSPACE = """\
+workspace(name = "{}")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "rules_cc",
+    urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.1/rules_cc-0.0.1.tar.gz"],
+    sha256 = "4dccbfd22c0def164c8f47458bd50e0c7148f3d92002cdb459c2a96a68498241",
+)
+"""
+
+_CLANG_BUILD_FILE = """\
+load("@rules_cc//cc:defs.bzl", "cc_import")
+
+package(default_visibility = ["//visibility:public"])
+
+sh_binary(
+    name = "clang",
+    srcs = ["bin/clang"],
+)
+
+cc_import(
+    name = "libclang",
+    shared_library = "lib/libclang.{suffix}",
+)
+
+alias(
+    name = "libclang.so",
+    actual = ":libclang",
+    deprecation = "Use :libclang instead",
+)
+
+cc_import(
+    name = "libc++",
+    shared_library = "lib/libc++.{suffix}"
+)
+"""
+
+def _bindgen_clang_repositories():
+    # Releases @ http://releases.llvm.org/download.html
+    maybe(
+        http_archive,
+        name = "bindgen_clang_linux",
+        urls = ["https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04.tar.xz"],
+        strip_prefix = "clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04",
+        sha256 = "b25f592a0c00686f03e3b7db68ca6dc87418f681f4ead4df4745a01d9be63843",
+        build_file_content = _CLANG_BUILD_FILE.format(suffix = "so"),
+        workspace_file_content = _COMMON_WORKSPACE.format("bindgen_clang_linux"),
+    )
+
+    maybe(
+        http_archive,
+        name = "bindgen_clang_osx",
+        urls = ["https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/clang+llvm-10.0.0-x86_64-apple-darwin.tar.xz"],
+        strip_prefix = "clang+llvm-10.0.0-x86_64-apple-darwin",
+        sha256 = "633a833396bf2276094c126b072d52b59aca6249e7ce8eae14c728016edb5e61",
+        build_file_content = _CLANG_BUILD_FILE.format(suffix = "dylib"),
+        workspace_file_content = _COMMON_WORKSPACE.format("bindgen_clang_osx"),
+    )
diff --git a/third_party/rules_rust/cargo/BUILD.bazel b/third_party/rules_rust/cargo/BUILD.bazel
new file mode 100644
index 0000000..8772c31
--- /dev/null
+++ b/third_party/rules_rust/cargo/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+
+package(default_visibility = ["//visibility:public"])
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+    deps = ["//cargo/private:bzl_lib"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//cargo:bzl_lib` target instead",
+)
diff --git a/third_party/rules_rust/cargo/bootstrap/BUILD.bazel b/third_party/rules_rust/cargo/bootstrap/BUILD.bazel
new file mode 100644
index 0000000..a607f60
--- /dev/null
+++ b/third_party/rules_rust/cargo/bootstrap/BUILD.bazel
@@ -0,0 +1,20 @@
+load("//rust:defs.bzl", "rust_binary")
+
+exports_files(
+    [
+        "bootstrap_installer.rs",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+# This target is only used to confirm the source code is buildable
+# in a `cargo_bootstrap_repository` rule.
+rust_binary(
+    name = "bootstrap_installer_bin",
+    srcs = [
+        "bootstrap_installer.rs",
+    ],
+    rustc_env = {
+        "RULES_RUST_CARGO_BOOTSTRAP_BINARY": "$(rootpath bootstrap_installer.rs)",
+    },
+)
diff --git a/third_party/rules_rust/cargo/bootstrap/bootstrap_installer.rs b/third_party/rules_rust/cargo/bootstrap/bootstrap_installer.rs
new file mode 100644
index 0000000..32cb137
--- /dev/null
+++ b/third_party/rules_rust/cargo/bootstrap/bootstrap_installer.rs
@@ -0,0 +1,35 @@
+//! A tool for installing bootstrapped Rust binaries into the requested paths.
+
+use std::{
+    env,
+    fs::{copy, create_dir_all},
+    path::PathBuf,
+};
+
+fn install() -> std::io::Result<u64> {
+    let binary = PathBuf::from(env!("RULES_RUST_CARGO_BOOTSTRAP_BINARY"));
+
+    // Consume only the first argument as the destination
+    let dest = PathBuf::from(
+        env::args()
+            .nth(1)
+            .expect("No destination argument provided"),
+    );
+
+    // Create the parent directory structure if it doesn't exist
+    if let Some(parent) = dest.parent() {
+        if !parent.exists() {
+            create_dir_all(parent)?;
+        }
+    }
+
+    // Copy the file to the requested destination
+    copy(binary, dest)
+}
+
+fn main() {
+    if let Err(err) = install() {
+        eprintln!("{:?}", err);
+        std::process::exit(1);
+    };
+}
diff --git a/third_party/rules_rust/cargo/cargo_bootstrap.bzl b/third_party/rules_rust/cargo/cargo_bootstrap.bzl
new file mode 100644
index 0000000..bbe35c0
--- /dev/null
+++ b/third_party/rules_rust/cargo/cargo_bootstrap.bzl
@@ -0,0 +1,339 @@
+"""The `cargo_bootstrap` rule is used for bootstrapping cargo binaries in a repository rule."""
+
+load("//cargo/private:cargo_utils.bzl", "get_host_triple", "get_rust_tools")
+load("//rust:defs.bzl", "rust_common")
+
+_CARGO_BUILD_MODES = [
+    "release",
+    "debug",
+]
+
+_FAIL_MESSAGE = """\
+Process exited with code '{code}'
+# ARGV ########################################################################
+{argv}
+
+# STDOUT ######################################################################
+{stdout}
+
+# STDERR ######################################################################
+{stderr}
+"""
+
+def cargo_bootstrap(
+        repository_ctx,
+        cargo_bin,
+        rustc_bin,
+        binary,
+        cargo_manifest,
+        environment = {},
+        quiet = False,
+        build_mode = "release",
+        target_dir = None,
+        timeout = 600):
+    """A function for bootstrapping a cargo binary within a repository rule
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        cargo_bin (path): The path to a Cargo binary.
+        rustc_bin (path): The path to a Rustc binary.
+        binary (str): The binary to build (the `--bin` parameter for Cargo).
+        cargo_manifest (path): The path to a Cargo manifest (Cargo.toml file).
+        environment (dict): Environment variables to use during execution.
+        quiet (bool, optional): Whether or not to print output from the Cargo command.
+        build_mode (str, optional): The build mode to use
+        target_dir (path, optional): The directory in which to produce build outputs
+            (Cargo's --target-dir argument).
+        timeout (int, optional): Maximum duration of the Cargo build command in seconds,
+
+    Returns:
+        path: The path of the built binary within the target directory
+    """
+
+    if not target_dir:
+        target_dir = repository_ctx.path(".")
+
+    args = [
+        cargo_bin,
+        "build",
+        "--bin",
+        binary,
+        "--locked",
+        "--target-dir",
+        target_dir,
+        "--manifest-path",
+        cargo_manifest,
+    ]
+
+    if build_mode not in _CARGO_BUILD_MODES:
+        fail("'{}' is not a supported build mode. Use one of {}".format(build_mode, _CARGO_BUILD_MODES))
+
+    if build_mode == "release":
+        args.append("--release")
+
+    env = dict({
+        "RUSTC": str(rustc_bin),
+    }.items() + environment.items())
+
+    repository_ctx.report_progress("Cargo Bootstrapping {}".format(binary))
+    result = repository_ctx.execute(
+        args,
+        environment = env,
+        quiet = quiet,
+        timeout = timeout,
+    )
+
+    if result.return_code != 0:
+        fail(_FAIL_MESSAGE.format(
+            code = result.return_code,
+            argv = args,
+            stdout = result.stdout,
+            stderr = result.stderr,
+        ))
+
+    extension = ""
+    if "win" in repository_ctx.os.name:
+        extension = ".exe"
+
+    binary_path = "{}/{}{}".format(
+        build_mode,
+        binary,
+        extension,
+    )
+
+    if not repository_ctx.path(binary_path).exists:
+        fail("Failed to produce binary at {}".format(binary_path))
+
+    return binary_path
+
+_BUILD_FILE_CONTENT = """\
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "{binary_name}",
+    "{binary}"
+])
+
+alias(
+    name = "binary",
+    actual = "{binary}",
+)
+
+rust_binary(
+    name = "install",
+    rustc_env = {{
+        "RULES_RUST_CARGO_BOOTSTRAP_BINARY": "$(rootpath {binary})"
+    }},
+    data = [
+        "{binary}",
+    ],
+    srcs = [
+        "@rules_rust//cargo/bootstrap:bootstrap_installer.rs"
+    ],
+)
+"""
+
+def _collect_environ(repository_ctx, host_triple):
+    """Gather environment varialbes to use from the current rule context
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        host_triple (str): A string of the current host triple
+
+    Returns:
+        dict: A map of environment variables
+    """
+    env_vars = dict(json.decode(repository_ctx.attr.env.get(host_triple, "{}")))
+
+    # Gather the path for each label and ensure it exists
+    env_labels = dict(json.decode(repository_ctx.attr.env_label.get(host_triple, "{}")))
+    env_labels = {key: repository_ctx.path(Label(value)) for (key, value) in env_labels.items()}
+    for key in env_labels:
+        if not env_labels[key].exists:
+            fail("File for key '{}' does not exist: {}", key, env_labels[key])
+    env_labels = {key: str(value) for (key, value) in env_labels.items()}
+
+    return dict(env_vars.items() + env_labels.items())
+
+def _detect_changes(repository_ctx):
+    """Inspect files that are considered inputs to the build for changes
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+    """
+    # Simply generating a `path` object consideres the file as 'tracked' or
+    # 'consumed' which means changes to it will trigger rebuilds
+
+    for src in repository_ctx.attr.srcs:
+        repository_ctx.path(src)
+
+    repository_ctx.path(repository_ctx.attr.cargo_lockfile)
+    repository_ctx.path(repository_ctx.attr.cargo_toml)
+
+def _cargo_bootstrap_repository_impl(repository_ctx):
+    # Pretend to Bazel that this rule's input files have been used, so that it will re-run the rule if they change.
+    _detect_changes(repository_ctx)
+
+    if repository_ctx.attr.version in ("beta", "nightly"):
+        version_str = "{}-{}".format(repository_ctx.attr.version, repository_ctx.attr.iso_date)
+    else:
+        version_str = repository_ctx.attr.version
+
+    host_triple = get_host_triple(repository_ctx)
+
+    if repository_ctx.attr.rust_toolchain_repository_template:
+        # buildifier: disable=print
+        print("Warning: `rust_toolchain_repository_template` is deprecated. Please use `rust_toolchain_cargo_template` and `rust_toolchain_rustc_template`")
+        cargo_template = "@{}{}".format(repository_ctx.attr.rust_toolchain_repository_template, "//:bin/{tool}")
+        rustc_template = "@{}{}".format(repository_ctx.attr.rust_toolchain_repository_template, "//:bin/{tool}")
+    else:
+        cargo_template = repository_ctx.attr.rust_toolchain_cargo_template
+        rustc_template = repository_ctx.attr.rust_toolchain_rustc_template
+
+    tools = get_rust_tools(
+        cargo_template = cargo_template,
+        rustc_template = rustc_template,
+        host_triple = host_triple,
+        version = version_str,
+    )
+
+    binary_name = repository_ctx.attr.binary or repository_ctx.name
+
+    # In addition to platform specific environment variables, a common set (indicated by `*`) will always
+    # be gathered.
+    environment = dict(_collect_environ(repository_ctx, "*").items() + _collect_environ(repository_ctx, host_triple.triple).items())
+
+    built_binary = cargo_bootstrap(
+        repository_ctx = repository_ctx,
+        cargo_bin = repository_ctx.path(tools.cargo),
+        rustc_bin = repository_ctx.path(tools.rustc),
+        binary = binary_name,
+        cargo_manifest = repository_ctx.path(repository_ctx.attr.cargo_toml),
+        build_mode = repository_ctx.attr.build_mode,
+        environment = environment,
+        timeout = repository_ctx.attr.timeout,
+    )
+
+    # Create a symlink so that the binary can be accesed via it's target name
+    repository_ctx.symlink(built_binary, binary_name)
+
+    repository_ctx.file("BUILD.bazel", _BUILD_FILE_CONTENT.format(
+        binary_name = binary_name,
+        binary = built_binary,
+    ))
+
+cargo_bootstrap_repository = repository_rule(
+    doc = "A rule for bootstrapping a Rust binary using [Cargo](https://doc.rust-lang.org/cargo/)",
+    implementation = _cargo_bootstrap_repository_impl,
+    attrs = {
+        "binary": attr.string(
+            doc = "The binary to build (the `--bin` parameter for Cargo). If left empty, the repository name will be used.",
+        ),
+        "build_mode": attr.string(
+            doc = "The build mode the binary should be built with",
+            values = [
+                "debug",
+                "release",
+            ],
+            default = "release",
+        ),
+        "cargo_lockfile": attr.label(
+            doc = "The lockfile of the crate_universe resolver",
+            allow_single_file = ["Cargo.lock"],
+            mandatory = True,
+        ),
+        "cargo_toml": attr.label(
+            doc = "The path of the crate_universe resolver manifest (`Cargo.toml` file)",
+            allow_single_file = ["Cargo.toml"],
+            mandatory = True,
+        ),
+        "env": attr.string_dict(
+            doc = (
+                "A mapping of platform triple to a set of environment variables. See " +
+                "[cargo_env](#cargo_env) for usage details. Additionally, the platform triple `*` applies to all platforms."
+            ),
+        ),
+        "env_label": attr.string_dict(
+            doc = (
+                "A mapping of platform triple to a set of environment variables. This " +
+                "attribute differs from `env` in that all variables passed here must be " +
+                "fully qualified labels of files. See [cargo_env](#cargo_env) for usage details. " +
+                "Additionally, the platform triple `*` applies to all platforms."
+            ),
+        ),
+        "iso_date": attr.string(
+            doc = "The iso_date of cargo binary the resolver should use. Note: This can only be set if `version` is `beta` or `nightly`",
+        ),
+        "rust_toolchain_cargo_template": attr.string(
+            doc = (
+                "The template to use for finding the host `cargo` binary. `{version}` (eg. '1.53.0'), " +
+                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
+                "`{system}` (eg. 'darwin'), and `{tool}` (eg. 'rustc.exe') will be replaced in the string if present."
+            ),
+            default = "@rust_{system}_{arch}//:bin/{tool}",
+        ),
+        "rust_toolchain_repository_template": attr.string(
+            doc = "**Deprecated**: Please use `rust_toolchain_cargo_template` and `rust_toolchain_rustc_template`",
+        ),
+        "rust_toolchain_rustc_template": attr.string(
+            doc = (
+                "The template to use for finding the host `rustc` binary. `{version}` (eg. '1.53.0'), " +
+                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
+                "`{system}` (eg. 'darwin'), and `{tool}` (eg. 'rustc.exe') will be replaced in the string if present."
+            ),
+            default = "@rust_{system}_{arch}//:bin/{tool}",
+        ),
+        "srcs": attr.label_list(
+            doc = "Souce files of the crate to build. Passing source files here can be used to trigger rebuilds when changes are made",
+            allow_files = True,
+        ),
+        "timeout": attr.int(
+            doc = "Maximum duration of the Cargo build command in seconds",
+            default = 600,
+        ),
+        "version": attr.string(
+            doc = "The version of cargo the resolver should use",
+            default = rust_common.default_version,
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+    },
+)
+
+def cargo_env(env):
+    """A helper for generating platform specific environment variables
+
+    ```python
+    load("@rules_rust//rust:defs.bzl", "rust_common")
+    load("@rules_rust//cargo:defs.bzl", "cargo_bootstrap_repository", "cargo_env")
+
+    cargo_bootstrap_repository(
+        name = "bootstrapped_bin",
+        cargo_lockfile = "//:Cargo.lock",
+        cargo_toml = "//:Cargo.toml",
+        srcs = ["//:resolver_srcs"],
+        version = rust_common.default_version,
+        binary = "my-crate-binary",
+        env = {
+            "x86_64-unknown-linux-gnu": cargo_env({
+                "FOO": "BAR",
+            }),
+        },
+        env_label = {
+            "aarch64-unknown-linux-musl": cargo_env({
+                "DOC": "//:README.md",
+            }),
+        }
+    )
+    ```
+
+    Args:
+        env (dict): A map of environment variables
+
+    Returns:
+        str: A json encoded string of the environment variables
+    """
+    return json.encode(dict(env))
diff --git a/third_party/rules_rust/cargo/cargo_build_script.bzl b/third_party/rules_rust/cargo/cargo_build_script.bzl
new file mode 100644
index 0000000..69450a2
--- /dev/null
+++ b/third_party/rules_rust/cargo/cargo_build_script.bzl
@@ -0,0 +1,396 @@
+# buildifier: disable=module-docstring
+load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "C_COMPILE_ACTION_NAME")
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
+load("//rust:defs.bzl", "rust_binary", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:rustc.bzl", "BuildInfo", "get_compilation_mode_opts", "get_linker_and_args")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "dedent", "expand_dict_value_locations", "find_cc_toolchain", "find_toolchain", "name_to_crate_name")
+
+def get_cc_compile_env(cc_toolchain, feature_configuration):
+    """Gather cc environment variables from the given `cc_toolchain`
+
+    Args:
+        cc_toolchain (cc_toolchain): The current rule's `cc_toolchain`.
+        feature_configuration (FeatureConfiguration): Class used to construct command lines from CROSSTOOL features.
+
+    Returns:
+        dict: Returns environment variables to be set for given action.
+    """
+    compile_variables = cc_common.create_compile_variables(
+        feature_configuration = feature_configuration,
+        cc_toolchain = cc_toolchain,
+    )
+    return cc_common.get_environment_variables(
+        feature_configuration = feature_configuration,
+        action_name = C_COMPILE_ACTION_NAME,
+        variables = compile_variables,
+    )
+
+def _build_script_impl(ctx):
+    """The implementation for the `_build_script_run` rule.
+
+    Args:
+        ctx (ctx): The rules context object
+
+    Returns:
+        list: A list containing a BuildInfo provider
+    """
+    script = ctx.executable.script
+    toolchain = find_toolchain(ctx)
+    out_dir = ctx.actions.declare_directory(ctx.label.name + ".out_dir")
+    env_out = ctx.actions.declare_file(ctx.label.name + ".env")
+    dep_env_out = ctx.actions.declare_file(ctx.label.name + ".depenv")
+    flags_out = ctx.actions.declare_file(ctx.label.name + ".flags")
+    link_flags = ctx.actions.declare_file(ctx.label.name + ".linkflags")
+    link_search_paths = ctx.actions.declare_file(ctx.label.name + ".linksearchpaths")  # rustc-link-search, propagated from transitive dependencies
+    manifest_dir = "%s.runfiles/%s/%s" % (script.path, ctx.label.workspace_name or ctx.workspace_name, ctx.label.package)
+    compilation_mode_opt_level = get_compilation_mode_opts(ctx, toolchain).opt_level
+
+    streams = struct(
+        stdout = ctx.actions.declare_file(ctx.label.name + ".stdout.log"),
+        stderr = ctx.actions.declare_file(ctx.label.name + ".stderr.log"),
+    )
+
+    pkg_name = _name_to_pkg_name(ctx.label.name)
+
+    toolchain_tools = [toolchain.all_files]
+
+    cc_toolchain = find_cpp_toolchain(ctx)
+
+    # Start with the default shell env, which contains any --action_env
+    # settings passed in on the command line.
+    env = dict(ctx.configuration.default_shell_env)
+
+    env.update({
+        "CARGO_CRATE_NAME": name_to_crate_name(pkg_name),
+        "CARGO_MANIFEST_DIR": manifest_dir,
+        "CARGO_PKG_NAME": pkg_name,
+        "HOST": toolchain.exec_triple,
+        "OPT_LEVEL": compilation_mode_opt_level,
+        "RUSTC": toolchain.rustc.path,
+        "TARGET": toolchain.target_flag_value,
+        # OUT_DIR is set by the runner itself, rather than on the action.
+    })
+
+    # This isn't exactly right, but Bazel doesn't have exact views of "debug" and "release", so...
+    env.update({
+        "DEBUG": {"dbg": "true", "fastbuild": "true", "opt": "false"}.get(ctx.var["COMPILATION_MODE"], "true"),
+        "PROFILE": {"dbg": "debug", "fastbuild": "debug", "opt": "release"}.get(ctx.var["COMPILATION_MODE"], "unknown"),
+    })
+
+    if ctx.attr.version:
+        version = ctx.attr.version.split("+")[0].split(".")
+        patch = version[2].split("-") if len(version) > 2 else [""]
+        env["CARGO_PKG_VERSION_MAJOR"] = version[0]
+        env["CARGO_PKG_VERSION_MINOR"] = version[1] if len(version) > 1 else ""
+        env["CARGO_PKG_VERSION_PATCH"] = patch[0]
+        env["CARGO_PKG_VERSION_PRE"] = patch[1] if len(patch) > 1 else ""
+        env["CARGO_PKG_VERSION"] = ctx.attr.version
+
+    # Pull in env vars which may be required for the cc_toolchain to work (e.g. on OSX, the SDK version).
+    # We hope that the linker env is sufficient for the whole cc_toolchain.
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+    linker, link_args, linker_env = get_linker_and_args(ctx, ctx.attr, cc_toolchain, feature_configuration, None)
+    env.update(**linker_env)
+    env["LD"] = linker
+    env["LDFLAGS"] = " ".join(link_args)
+
+    # MSVC requires INCLUDE to be set
+    cc_env = get_cc_compile_env(cc_toolchain, feature_configuration)
+    include = cc_env.get("INCLUDE")
+    if include:
+        env["INCLUDE"] = include
+
+    if cc_toolchain:
+        toolchain_tools.append(cc_toolchain.all_files)
+
+        cc_executable = cc_toolchain.compiler_executable
+        if cc_executable:
+            env["CC"] = cc_executable
+            env["CXX"] = cc_executable
+        ar_executable = cc_toolchain.ar_executable
+        if ar_executable:
+            env["AR"] = ar_executable
+        if cc_toolchain.sysroot:
+            env["SYSROOT"] = cc_toolchain.sysroot
+
+    # Inform build scripts of rustc flags
+    # https://github.com/rust-lang/cargo/issues/9600
+    env["CARGO_ENCODED_RUSTFLAGS"] = "\\x1f".join([
+        # Allow build scripts to locate the generated sysroot
+        "--sysroot=${{pwd}}/{}".format(toolchain.sysroot),
+    ] + ctx.attr.rustc_flags)
+
+    for f in ctx.attr.crate_features:
+        env["CARGO_FEATURE_" + f.upper().replace("-", "_")] = "1"
+
+    env.update(expand_dict_value_locations(
+        ctx,
+        ctx.attr.build_script_env,
+        getattr(ctx.attr, "data", []) +
+        getattr(ctx.attr, "compile_data", []) +
+        getattr(ctx.attr, "tools", []),
+    ))
+
+    tools = depset(
+        direct = [
+            script,
+            ctx.executable._cargo_build_script_runner,
+        ] + ctx.files.data + ctx.files.tools + ([toolchain.target_json] if toolchain.target_json else []),
+        transitive = toolchain_tools,
+    )
+
+    links = ctx.attr.links or ""
+
+    # dep_env_file contains additional environment variables coming from
+    # direct dependency sys-crates' build scripts. These need to be made
+    # available to the current crate build script.
+    # See https://doc.rust-lang.org/cargo/reference/build-scripts.html#-sys-packages
+    # for details.
+    args = ctx.actions.args()
+    args.add_all([
+        script.path,
+        links,
+        out_dir.path,
+        env_out.path,
+        flags_out.path,
+        link_flags.path,
+        link_search_paths.path,
+        dep_env_out.path,
+        streams.stdout.path,
+        streams.stderr.path,
+    ])
+    build_script_inputs = []
+    for dep in ctx.attr.deps:
+        if rust_common.dep_info in dep and dep[rust_common.dep_info].dep_env:
+            dep_env_file = dep[rust_common.dep_info].dep_env
+            args.add(dep_env_file.path)
+            build_script_inputs.append(dep_env_file)
+            for dep_build_info in dep[rust_common.dep_info].transitive_build_infos.to_list():
+                build_script_inputs.append(dep_build_info.out_dir)
+
+    ctx.actions.run(
+        executable = ctx.executable._cargo_build_script_runner,
+        arguments = [args],
+        outputs = [out_dir, env_out, flags_out, link_flags, link_search_paths, dep_env_out, streams.stdout, streams.stderr],
+        tools = tools,
+        inputs = build_script_inputs,
+        mnemonic = "CargoBuildScriptRun",
+        progress_message = "Running Cargo build script {}".format(pkg_name),
+        env = env,
+    )
+
+    return [
+        BuildInfo(
+            out_dir = out_dir,
+            rustc_env = env_out,
+            dep_env = dep_env_out,
+            flags = flags_out,
+            link_flags = link_flags,
+            link_search_paths = link_search_paths,
+        ),
+        OutputGroupInfo(streams = depset([streams.stdout, streams.stderr])),
+    ]
+
+_build_script_run = rule(
+    doc = (
+        "A rule for running a crate's `build.rs` files to generate build information " +
+        "which is then used to determine how to compile said crate."
+    ),
+    implementation = _build_script_impl,
+    attrs = {
+        "build_script_env": attr.string_dict(
+            doc = "Environment variables for build scripts.",
+        ),
+        "crate_features": attr.string_list(
+            doc = "The list of rust features that the build script should consider activated.",
+        ),
+        "data": attr.label_list(
+            doc = "Data required by the build script.",
+            allow_files = True,
+        ),
+        "deps": attr.label_list(
+            doc = "The Rust dependencies of the crate",
+            providers = [rust_common.dep_info],
+        ),
+        "links": attr.string(
+            doc = "The name of the native library this crate links against.",
+        ),
+        "rustc_flags": attr.string_list(
+            doc = dedent("""\
+                List of compiler flags passed to `rustc`.
+
+                These strings are subject to Make variable expansion for predefined
+                source/output path variables like `$location`, `$execpath`, and 
+                `$rootpath`. This expansion is useful if you wish to pass a generated
+                file of arguments to rustc: `@$(location //package:target)`.
+            """),
+        ),
+        # The source of truth will be the `cargo_build_script` macro until stardoc
+        # implements documentation inheritence. See https://github.com/bazelbuild/stardoc/issues/27
+        "script": attr.label(
+            doc = "The binary script to run, generally a `rust_binary` target.",
+            executable = True,
+            allow_files = True,
+            mandatory = True,
+            cfg = "exec",
+        ),
+        "tools": attr.label_list(
+            doc = "Tools required by the build script.",
+            allow_files = True,
+            cfg = "exec",
+        ),
+        "version": attr.string(
+            doc = "The semantic version (semver) of the crate",
+        ),
+        "_cargo_build_script_runner": attr.label(
+            executable = True,
+            allow_files = True,
+            default = Label("//cargo/cargo_build_script_runner:cargo_build_script_runner"),
+            cfg = "exec",
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+    },
+    fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+)
+
+def cargo_build_script(
+        name,
+        crate_features = [],
+        version = None,
+        deps = [],
+        build_script_env = {},
+        data = [],
+        tools = [],
+        links = None,
+        rustc_env = {},
+        rustc_flags = [],
+        visibility = None,
+        tags = None,
+        **kwargs):
+    """Compile and execute a rust build script to generate build attributes
+
+    This rules take the same arguments as rust_binary.
+
+    Example:
+
+    Suppose you have a crate with a cargo build script `build.rs`:
+
+    ```output
+    [workspace]/
+        hello_lib/
+            BUILD
+            build.rs
+            src/
+                lib.rs
+    ```
+
+    Then you want to use the build script in the following:
+
+    `hello_lib/BUILD`:
+    ```python
+    package(default_visibility = ["//visibility:public"])
+
+    load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
+    load("@rules_rust//cargo:cargo_build_script.bzl", "cargo_build_script")
+
+    # This will run the build script from the root of the workspace, and
+    # collect the outputs.
+    cargo_build_script(
+        name = "build_script",
+        srcs = ["build.rs"],
+        # Optional environment variables passed during build.rs compilation
+        rustc_env = {
+           "CARGO_PKG_VERSION": "0.1.2",
+        },
+        # Optional environment variables passed during build.rs execution.
+        # Note that as the build script's working directory is not execroot,
+        # execpath/location will return an absolute path, instead of a relative
+        # one.
+        build_script_env = {
+            "SOME_TOOL_OR_FILE": "$(execpath @tool//:binary)"
+        }
+        # Optional data/tool dependencies
+        data = ["@tool//:binary"],
+    )
+
+    rust_library(
+        name = "hello_lib",
+        srcs = [
+            "src/lib.rs",
+        ],
+        deps = [":build_script"],
+    )
+    ```
+
+    The `hello_lib` target will be build with the flags and the environment variables declared by the \
+    build script in addition to the file generated by it.
+
+    Args:
+        name (str): The name for the underlying rule. This should be the name of the package being compiled, optionally with a suffix of _build_script.
+        crate_features (list, optional): A list of features to enable for the build script.
+        version (str, optional): The semantic version (semver) of the crate.
+        deps (list, optional): The dependencies of the crate.
+        build_script_env (dict, optional): Environment variables for build scripts.
+        data (list, optional): Files needed by the build script.
+        tools (list, optional): Tools (executables) needed by the build script.
+        links (str, optional): Name of the native library this crate links against.
+        rustc_env (dict, optional): Environment variables to set in rustc when compiling the build script.
+        rustc_flags (list, optional): List of compiler flags passed to `rustc`.
+        visibility (list of label, optional): Visibility to apply to the generated build script output.
+        tags: (list of str, optional): Tags to apply to the generated build script output.
+        **kwargs: Forwards to the underlying `rust_binary` rule.
+    """
+
+    # This duplicates the code in _build_script_impl because we need to make these available both when we invoke rustc (this code) and when we run the compiled build script (_build_script_impl).
+    # https://github.com/bazelbuild/rules_rust/issues/661 will hopefully remove this duplication.
+    rustc_env = dict(rustc_env)
+    if "CARGO_PKG_NAME" not in rustc_env:
+        rustc_env["CARGO_PKG_NAME"] = _name_to_pkg_name(name)
+    if "CARGO_CRATE_NAME" not in rustc_env:
+        rustc_env["CARGO_CRATE_NAME"] = name_to_crate_name(_name_to_pkg_name(name))
+
+    binary_tags = [tag for tag in tags or []]
+    if "manual" not in binary_tags:
+        binary_tags.append("manual")
+
+    rust_binary(
+        name = name + "_",
+        crate_features = crate_features,
+        version = version,
+        deps = deps,
+        data = data,
+        rustc_env = rustc_env,
+        rustc_flags = rustc_flags,
+        tags = binary_tags,
+        **kwargs
+    )
+    _build_script_run(
+        name = name,
+        script = ":{}_".format(name),
+        crate_features = crate_features,
+        version = version,
+        build_script_env = build_script_env,
+        links = links,
+        deps = deps,
+        data = data,
+        tools = tools,
+        rustc_flags = rustc_flags,
+        visibility = visibility,
+        tags = tags,
+    )
+
+def _name_to_pkg_name(name):
+    if name.endswith("_build_script"):
+        return name[:-len("_build_script")]
+    return name
diff --git a/third_party/rules_rust/cargo/cargo_build_script_runner/BUILD.bazel b/third_party/rules_rust/cargo/cargo_build_script_runner/BUILD.bazel
new file mode 100644
index 0000000..11edd45
--- /dev/null
+++ b/third_party/rules_rust/cargo/cargo_build_script_runner/BUILD.bazel
@@ -0,0 +1,24 @@
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
+
+rust_library(
+    name = "cargo_build_script_output_parser",
+    srcs = ["lib.rs"],
+)
+
+rust_test(
+    name = "test",
+    crate = ":cargo_build_script_output_parser",
+)
+
+rust_binary(
+    name = "cargo_build_script_runner",
+    srcs = ["bin.rs"],
+    visibility = ["//visibility:public"],
+    deps = [":cargo_build_script_output_parser"],
+)
+
+rust_test(
+    name = "bin_test",
+    crate = ":cargo_build_script_runner",
+    deps = [":cargo_build_script_runner"],
+)
diff --git a/third_party/rules_rust/cargo/cargo_build_script_runner/bin.rs b/third_party/rules_rust/cargo/cargo_build_script_runner/bin.rs
new file mode 100644
index 0000000..58f0363
--- /dev/null
+++ b/third_party/rules_rust/cargo/cargo_build_script_runner/bin.rs
@@ -0,0 +1,345 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+// A simple wrapper around a build_script execution to generate file to reuse
+// by rust_library/rust_binary.
+extern crate cargo_build_script_output_parser;
+
+use cargo_build_script_output_parser::{BuildScriptOutput, CompileAndLinkFlags};
+use std::collections::BTreeMap;
+use std::env;
+use std::fs::{create_dir_all, read_to_string, write};
+use std::path::Path;
+use std::process::Command;
+
+fn run_buildrs() -> Result<(), String> {
+    // We use exec_root.join rather than std::fs::canonicalize, to avoid resolving symlinks, as
+    // some execution strategies and remote execution environments may use symlinks in ways which
+    // canonicalizing them may break them, e.g. by having input files be symlinks into a /cas
+    // directory - resolving these may cause tools which inspect $0, or try to resolve files
+    // relative to themselves, to fail.
+    let exec_root = env::current_dir().expect("Failed to get current directory");
+    let manifest_dir_env = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR was not set");
+    let rustc_env = env::var("RUSTC").expect("RUSTC was not set");
+    let manifest_dir = exec_root.join(&manifest_dir_env);
+    let rustc = exec_root.join(&rustc_env);
+    let Options {
+        progname,
+        crate_links,
+        out_dir,
+        env_file,
+        compile_flags_file,
+        link_flags_file,
+        link_search_paths_file,
+        output_dep_env_path,
+        stdout_path,
+        stderr_path,
+        input_dep_env_paths,
+    } = parse_args()?;
+
+    let out_dir_abs = exec_root.join(&out_dir);
+    // For some reason Google's RBE does not create the output directory, force create it.
+    create_dir_all(&out_dir_abs)
+        .unwrap_or_else(|_| panic!("Failed to make output directory: {:?}", out_dir_abs));
+
+    let target_env_vars =
+        get_target_env_vars(&rustc_env).expect("Error getting target env vars from rustc");
+
+    let mut command = Command::new(exec_root.join(&progname));
+    command
+        .current_dir(&manifest_dir)
+        .envs(target_env_vars)
+        .env("OUT_DIR", out_dir_abs)
+        .env("CARGO_MANIFEST_DIR", manifest_dir)
+        .env("RUSTC", rustc)
+        .env("RUST_BACKTRACE", "full");
+
+    for dep_env_path in input_dep_env_paths.iter() {
+        if let Ok(contents) = read_to_string(dep_env_path) {
+            for line in contents.split('\n') {
+                // split on empty contents will still produce a single empty string in iterable.
+                if line.is_empty() {
+                    continue;
+                }
+                let mut key_val = line.splitn(2, '=');
+                match (key_val.next(), key_val.next()) {
+                    (Some(key), Some(value)) => {
+                        command.env(key, value.replace("${pwd}", &exec_root.to_string_lossy()));
+                    }
+                    _ => {
+                        return Err(
+                            "error: Wrong environment file format, should not happen".to_owned()
+                        )
+                    }
+                }
+            }
+        } else {
+            return Err("error: Dependency environment file unreadable".to_owned());
+        }
+    }
+
+    for compiler_env_var in &["CC", "CXX"] {
+        if let Some(compiler_path) = env::var_os(compiler_env_var) {
+            let mut compiler_path = exec_root.join(compiler_path).into_os_string();
+            if let Some(sysroot_path) = env::var_os("SYSROOT") {
+                compiler_path.push(" --sysroot=");
+                compiler_path.push(&exec_root.join(sysroot_path));
+            }
+            command.env(compiler_env_var, compiler_path);
+        }
+    }
+
+    if let Some(ar_path) = env::var_os("AR") {
+        // The default OSX toolchain uses libtool as ar_executable not ar.
+        // This doesn't work when used as $AR, so simply don't set it - tools will probably fall back to
+        // /usr/bin/ar which is probably good enough.
+        if Path::new(&ar_path).file_name() == Some("libtool".as_ref()) {
+            command.env_remove("AR");
+        } else {
+            command.env("AR", exec_root.join(ar_path));
+        }
+    }
+
+    if let Some(ld_path) = env::var_os("LD") {
+        command.env("LD", exec_root.join(ld_path));
+    }
+
+    // replace env vars with a ${pwd} prefix with the exec_root
+    for (key, value) in env::vars() {
+        let exec_root_str = exec_root.to_str().expect("exec_root not in utf8");
+        if value.contains("${pwd}") {
+            env::set_var(key, value.replace("${pwd}", exec_root_str));
+        }
+    }
+
+    // Bazel does not support byte strings so in order to correctly represent `CARGO_ENCODED_RUSTFLAGS`
+    // the escaped `\x1f` sequences need to be unescaped
+    if let Ok(encoded_rustflags) = env::var("CARGO_ENCODED_RUSTFLAGS") {
+        command.env(
+            "CARGO_ENCODED_RUSTFLAGS",
+            encoded_rustflags.replace("\\x1f", "\x1f"),
+        );
+    }
+
+    let (buildrs_outputs, process_output) = BuildScriptOutput::outputs_from_command(&mut command)
+        .map_err(|process_output| {
+        format!(
+            "Build script process failed{}\n--stdout:\n{}\n--stderr:\n{}",
+            if let Some(exit_code) = process_output.status.code() {
+                format!(" with exit code {}", exit_code)
+            } else {
+                String::new()
+            },
+            String::from_utf8(process_output.stdout)
+                .expect("Failed to parse stdout of child process"),
+            String::from_utf8(process_output.stderr)
+                .expect("Failed to parse stdout of child process"),
+        )
+    })?;
+
+    write(
+        &env_file,
+        BuildScriptOutput::outputs_to_env(&buildrs_outputs, &exec_root.to_string_lossy())
+            .as_bytes(),
+    )
+    .unwrap_or_else(|_| panic!("Unable to write file {:?}", env_file));
+    write(
+        &output_dep_env_path,
+        BuildScriptOutput::outputs_to_dep_env(
+            &buildrs_outputs,
+            &crate_links,
+            &exec_root.to_string_lossy(),
+        )
+        .as_bytes(),
+    )
+    .unwrap_or_else(|_| panic!("Unable to write file {:?}", output_dep_env_path));
+    write(&stdout_path, process_output.stdout)
+        .unwrap_or_else(|_| panic!("Unable to write file {:?}", stdout_path));
+    write(&stderr_path, process_output.stderr)
+        .unwrap_or_else(|_| panic!("Unable to write file {:?}", stderr_path));
+
+    let CompileAndLinkFlags {
+        compile_flags,
+        link_flags,
+        link_search_paths,
+    } = BuildScriptOutput::outputs_to_flags(&buildrs_outputs, &exec_root.to_string_lossy());
+
+    write(&compile_flags_file, compile_flags.as_bytes())
+        .unwrap_or_else(|_| panic!("Unable to write file {:?}", compile_flags_file));
+    write(&link_flags_file, link_flags.as_bytes())
+        .unwrap_or_else(|_| panic!("Unable to write file {:?}", link_flags_file));
+    write(&link_search_paths_file, link_search_paths.as_bytes())
+        .unwrap_or_else(|_| panic!("Unable to write file {:?}", link_search_paths_file));
+    Ok(())
+}
+
+/// A representation of expected command line arguments.
+struct Options {
+    progname: String,
+    crate_links: String,
+    out_dir: String,
+    env_file: String,
+    compile_flags_file: String,
+    link_flags_file: String,
+    link_search_paths_file: String,
+    output_dep_env_path: String,
+    stdout_path: String,
+    stderr_path: String,
+    input_dep_env_paths: Vec<String>,
+}
+
+/// Parses positional comamnd line arguments into a well defined struct
+fn parse_args() -> Result<Options, String> {
+    let mut args = env::args().skip(1);
+
+    // TODO: we should consider an alternative to positional arguments.
+    match (args.next(), args.next(), args.next(), args.next(), args.next(), args.next(), args.next(), args.next(), args.next(), args.next()) {
+        (
+            Some(progname),
+            Some(crate_links),
+            Some(out_dir),
+            Some(env_file),
+            Some(compile_flags_file),
+            Some(link_flags_file),
+            Some(link_search_paths_file),
+            Some(output_dep_env_path),
+            Some(stdout_path),
+            Some(stderr_path),
+        ) => {
+            Ok(Options{
+                progname,
+                crate_links,
+                out_dir,
+                env_file,
+                compile_flags_file,
+                link_flags_file,
+                link_search_paths_file,
+                output_dep_env_path,
+                stdout_path,
+                stderr_path,
+                input_dep_env_paths: args.collect(),
+            })
+        }
+        _ => {
+            Err(format!("Usage: $0 progname crate_links out_dir env_file compile_flags_file link_flags_file link_search_paths_file output_dep_env_path stdout_path stderr_path input_dep_env_paths[arg1...argn]\nArguments passed: {:?}", args.collect::<Vec<String>>()))
+        }
+    }
+}
+
+fn get_target_env_vars<P: AsRef<Path>>(rustc: &P) -> Result<BTreeMap<String, String>, String> {
+    // As done by Cargo when constructing a cargo::core::compiler::build_context::target_info::TargetInfo.
+    let output = Command::new(rustc.as_ref())
+        .arg("--print=cfg")
+        .arg(format!(
+            "--target={}",
+            env::var("TARGET").expect("missing TARGET")
+        ))
+        .output()
+        .map_err(|err| format!("Error running rustc to get target information: {}", err))?;
+    if !output.status.success() {
+        return Err(format!(
+            "Error running rustc to get target information: {:?}",
+            output
+        ));
+    }
+    let stdout = std::str::from_utf8(&output.stdout)
+        .map_err(|err| format!("Non-UTF8 stdout from rustc: {:?}", err))?;
+
+    Ok(parse_rustc_cfg_output(stdout))
+}
+
+fn parse_rustc_cfg_output(stdout: &str) -> BTreeMap<String, String> {
+    let mut values = BTreeMap::new();
+
+    for line in stdout.lines() {
+        if line.starts_with("target_") && line.contains('=') {
+            let mut parts = line.splitn(2, '=');
+            // UNWRAP: Verified that line contains = and split into exactly 2 parts.
+            let key = parts.next().unwrap();
+            let value = parts.next().unwrap();
+            if value.starts_with('"') && value.ends_with('"') && value.len() >= 2 {
+                values
+                    .entry(key)
+                    .or_insert_with(Vec::new)
+                    .push(value[1..(value.len() - 1)].to_owned());
+            }
+        } else if ["windows", "unix"].contains(&line) {
+            // the 'windows' or 'unix' line received from rustc will be turned
+            // into eg. CARGO_CFG_WINDOWS='' below
+            values.insert(line, vec![]);
+        }
+    }
+
+    values
+        .into_iter()
+        .map(|(key, value)| (format!("CARGO_CFG_{}", key.to_uppercase()), value.join(",")))
+        .collect()
+}
+
+fn main() {
+    std::process::exit(match run_buildrs() {
+        Ok(_) => 0,
+        Err(err) => {
+            // Neatly print errors
+            eprintln!("{}", err);
+            1
+        }
+    });
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn rustc_cfg_parsing() {
+        let macos_output = r#"\
+debug_assertions
+target_arch="x86_64"
+target_endian="little"
+target_env=""
+target_family="unix"
+target_feature="fxsr"
+target_feature="sse"
+target_feature="sse2"
+target_feature="sse3"
+target_feature="ssse3"
+target_os="macos"
+target_pointer_width="64"
+target_vendor="apple"
+unix
+"#;
+        let tree = parse_rustc_cfg_output(macos_output);
+        assert_eq!(tree["CARGO_CFG_UNIX"], "");
+        assert_eq!(tree["CARGO_CFG_TARGET_FAMILY"], "unix");
+
+        let windows_output = r#"\
+debug_assertions
+target_arch="x86_64"
+target_endian="little"
+target_env="msvc"
+target_family="windows"
+target_feature="fxsr"
+target_feature="sse"
+target_feature="sse2"
+target_os="windows"
+target_pointer_width="64"
+target_vendor="pc"
+windows
+"#;
+        let tree = parse_rustc_cfg_output(windows_output);
+        assert_eq!(tree["CARGO_CFG_WINDOWS"], "");
+        assert_eq!(tree["CARGO_CFG_TARGET_FAMILY"], "windows");
+    }
+}
diff --git a/third_party/rules_rust/cargo/cargo_build_script_runner/lib.rs b/third_party/rules_rust/cargo/cargo_build_script_runner/lib.rs
new file mode 100644
index 0000000..b1aa793
--- /dev/null
+++ b/third_party/rules_rust/cargo/cargo_build_script_runner/lib.rs
@@ -0,0 +1,291 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+//! Parse the output of a cargo build.rs script and generate a list of flags and
+//! environment variable for the build.
+use std::io::{BufRead, BufReader, Read};
+use std::process::{Command, Output};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct CompileAndLinkFlags {
+    pub compile_flags: String,
+    pub link_flags: String,
+    pub link_search_paths: String,
+}
+
+/// Enum containing all the considered return value from the script
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BuildScriptOutput {
+    /// cargo:rustc-link-lib
+    LinkLib(String),
+    /// cargo:rustc-link-search
+    LinkSearch(String),
+    /// cargo:rustc-cfg
+    Cfg(String),
+    /// cargo:rustc-flags
+    Flags(String),
+    /// cargo:rustc-link-arg
+    LinkArg(String),
+    /// cargo:rustc-env
+    Env(String),
+    /// cargo:VAR=VALUE
+    DepEnv(String),
+}
+
+impl BuildScriptOutput {
+    /// Converts a line into a [BuildScriptOutput] enum.
+    ///
+    /// Examples
+    /// ```rust
+    /// assert_eq!(BuildScriptOutput::new("cargo:rustc-link-lib=lib"), Some(BuildScriptOutput::LinkLib("lib".to_owned())));
+    /// ```
+    fn new(line: &str) -> Option<BuildScriptOutput> {
+        let split = line.splitn(2, '=').collect::<Vec<_>>();
+        if split.len() <= 1 {
+            // Not a cargo directive.
+            return None;
+        }
+        let param = split[1].trim().to_owned();
+        let key_split = split[0].splitn(2, ':').collect::<Vec<_>>();
+        if key_split.len() <= 1 || key_split[0] != "cargo" {
+            // Not a cargo directive.
+            return None;
+        }
+
+        match key_split[1] {
+            "rustc-link-lib" => Some(BuildScriptOutput::LinkLib(param)),
+            "rustc-link-search" => Some(BuildScriptOutput::LinkSearch(param)),
+            "rustc-cfg" => Some(BuildScriptOutput::Cfg(param)),
+            "rustc-flags" => Some(BuildScriptOutput::Flags(param)),
+            "rustc-link-arg" => Some(BuildScriptOutput::LinkArg(param)),
+            "rustc-env" => Some(BuildScriptOutput::Env(param)),
+            "rerun-if-changed" | "rerun-if-env-changed" =>
+            // Ignored because Bazel will re-run if those change all the time.
+            {
+                None
+            }
+            "warning" => {
+                eprint!("Build Script Warning: {}", split[1]);
+                None
+            }
+            "rustc-cdylib-link-arg" | "rustc-link-arg-bin" | "rustc-link-arg-bins" => {
+                // cargo:rustc-cdylib-link-arg=FLAG — Passes custom flags to a linker for cdylib crates.
+                // cargo:rustc-link-arg-bin=BIN=FLAG – Passes custom flags to a linker for the binary BIN.
+                // cargo:rustc-link-arg-bins=FLAG – Passes custom flags to a linker for binaries.
+                eprint!(
+                    "Warning: build script returned unsupported directive `{}`",
+                    split[0]
+                );
+                None
+            }
+            _ => {
+                // cargo:KEY=VALUE — Metadata, used by links scripts.
+                Some(BuildScriptOutput::DepEnv(format!(
+                    "{}={}",
+                    key_split[1].to_uppercase(),
+                    param
+                )))
+            }
+        }
+    }
+
+    /// Converts a [BufReader] into a vector of [BuildScriptOutput] enums.
+    fn outputs_from_reader<T: Read>(mut reader: BufReader<T>) -> Vec<BuildScriptOutput> {
+        let mut result = Vec::<BuildScriptOutput>::new();
+        let mut line = String::new();
+        while reader.read_line(&mut line).expect("Cannot read line") != 0 {
+            if let Some(bso) = BuildScriptOutput::new(&line) {
+                result.push(bso);
+            }
+            line.clear();
+        }
+        result
+    }
+
+    /// Take a [Command], execute it and converts its input into a vector of [BuildScriptOutput]
+    pub fn outputs_from_command(
+        cmd: &mut Command,
+    ) -> Result<(Vec<BuildScriptOutput>, Output), Output> {
+        let child_output = cmd.output().expect("Unable to start binary");
+        if child_output.status.success() {
+            let reader = BufReader::new(child_output.stdout.as_slice());
+            let output = Self::outputs_from_reader(reader);
+            Ok((output, child_output))
+        } else {
+            Err(child_output)
+        }
+    }
+
+    /// Convert a vector of [BuildScriptOutput] into a list of environment variables.
+    pub fn outputs_to_env(outputs: &[BuildScriptOutput], exec_root: &str) -> String {
+        outputs
+            .iter()
+            .filter_map(|x| {
+                if let BuildScriptOutput::Env(env) = x {
+                    Some(Self::escape_for_serializing(Self::redact_exec_root(
+                        env, exec_root,
+                    )))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    /// Convert a vector of [BuildScriptOutput] into a list of dependencies environment variables.
+    pub fn outputs_to_dep_env(
+        outputs: &[BuildScriptOutput],
+        crate_links: &str,
+        exec_root: &str,
+    ) -> String {
+        let prefix = format!("DEP_{}_", crate_links.replace('-', "_").to_uppercase());
+        outputs
+            .iter()
+            .filter_map(|x| {
+                if let BuildScriptOutput::DepEnv(env) = x {
+                    Some(format!(
+                        "{}{}",
+                        prefix,
+                        Self::escape_for_serializing(Self::redact_exec_root(env, exec_root))
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    /// Convert a vector of [BuildScriptOutput] into a flagfile.
+    pub fn outputs_to_flags(outputs: &[BuildScriptOutput], exec_root: &str) -> CompileAndLinkFlags {
+        let mut compile_flags = Vec::new();
+        let mut link_flags = Vec::new();
+        let mut link_search_paths = Vec::new();
+
+        for flag in outputs {
+            match flag {
+                BuildScriptOutput::Cfg(e) => compile_flags.push(format!("--cfg={}", e)),
+                BuildScriptOutput::Flags(e) => compile_flags.push(e.to_owned()),
+                BuildScriptOutput::LinkArg(e) => compile_flags.push(format!("-Clink-arg={}", e)),
+                BuildScriptOutput::LinkLib(e) => link_flags.push(format!("-l{}", e)),
+                BuildScriptOutput::LinkSearch(e) => link_search_paths.push(format!("-L{}", e)),
+                _ => {}
+            }
+        }
+
+        CompileAndLinkFlags {
+            compile_flags: compile_flags.join("\n"),
+            link_flags: Self::redact_exec_root(&link_flags.join("\n"), exec_root),
+            link_search_paths: Self::redact_exec_root(&link_search_paths.join("\n"), exec_root),
+        }
+    }
+
+    fn redact_exec_root(value: &str, exec_root: &str) -> String {
+        value.replace(exec_root, "${pwd}")
+    }
+
+    // The process-wrapper treats trailing backslashes as escapes for following newlines.
+    // If the env var ends with a backslash (and accordingly doesn't have a following newline),
+    // escape it so that it doesn't get turned into a newline by the process-wrapper.
+    //
+    // Note that this code doesn't handle newlines in strings - that's because Cargo treats build
+    // script output as single-line-oriented, so stops processing at the end of a line regardless.
+    fn escape_for_serializing(mut value: String) -> String {
+        if value.ends_with('\\') {
+            value.push('\\');
+        }
+        value
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_from_read_buffer_to_env_and_flags() {
+        let buff = Cursor::new(
+            "
+cargo:rustc-link-lib=sdfsdf
+cargo:rustc-env=FOO=BAR
+cargo:rustc-link-search=/some/absolute/path/bleh
+cargo:rustc-env=BAR=FOO
+cargo:rustc-flags=-Lblah
+cargo:rerun-if-changed=ignored
+cargo:rustc-cfg=feature=awesome
+cargo:version=123
+cargo:version_number=1010107f
+cargo:include_path=/some/absolute/path/include
+cargo:rustc-env=SOME_PATH=/some/absolute/path/beep
+cargo:rustc-link-arg=-weak_framework
+cargo:rustc-link-arg=Metal
+",
+        );
+        let reader = BufReader::new(buff);
+        let result = BuildScriptOutput::outputs_from_reader(reader);
+        assert_eq!(result.len(), 12);
+        assert_eq!(result[0], BuildScriptOutput::LinkLib("sdfsdf".to_owned()));
+        assert_eq!(result[1], BuildScriptOutput::Env("FOO=BAR".to_owned()));
+        assert_eq!(
+            result[2],
+            BuildScriptOutput::LinkSearch("/some/absolute/path/bleh".to_owned())
+        );
+        assert_eq!(result[3], BuildScriptOutput::Env("BAR=FOO".to_owned()));
+        assert_eq!(result[4], BuildScriptOutput::Flags("-Lblah".to_owned()));
+        assert_eq!(
+            result[5],
+            BuildScriptOutput::Cfg("feature=awesome".to_owned())
+        );
+        assert_eq!(
+            result[6],
+            BuildScriptOutput::DepEnv("VERSION=123".to_owned())
+        );
+        assert_eq!(
+            result[7],
+            BuildScriptOutput::DepEnv("VERSION_NUMBER=1010107f".to_owned())
+        );
+        assert_eq!(
+            result[9],
+            BuildScriptOutput::Env("SOME_PATH=/some/absolute/path/beep".to_owned())
+        );
+        assert_eq!(
+            result[10],
+            BuildScriptOutput::LinkArg("-weak_framework".to_owned())
+        );
+        assert_eq!(result[11], BuildScriptOutput::LinkArg("Metal".to_owned()));
+
+        assert_eq!(
+            BuildScriptOutput::outputs_to_dep_env(&result, "ssh2", "/some/absolute/path"),
+            "DEP_SSH2_VERSION=123\nDEP_SSH2_VERSION_NUMBER=1010107f\nDEP_SSH2_INCLUDE_PATH=${pwd}/include".to_owned()
+        );
+        assert_eq!(
+            BuildScriptOutput::outputs_to_env(&result, "/some/absolute/path"),
+            "FOO=BAR\nBAR=FOO\nSOME_PATH=${pwd}/beep".to_owned()
+        );
+        assert_eq!(
+            BuildScriptOutput::outputs_to_flags(&result, "/some/absolute/path"),
+            CompileAndLinkFlags {
+                // -Lblah was output as a rustc-flags, so even though it probably _should_ be a link
+                // flag, we don't treat it like one.
+                compile_flags:
+                    "-Lblah\n--cfg=feature=awesome\n-Clink-arg=-weak_framework\n-Clink-arg=Metal"
+                        .to_owned(),
+                link_flags: "-lsdfsdf".to_owned(),
+                link_search_paths: "-L${pwd}/bleh".to_owned(),
+            }
+        );
+    }
+}
diff --git a/third_party/rules_rust/cargo/defs.bzl b/third_party/rules_rust/cargo/defs.bzl
new file mode 100644
index 0000000..0ca086b
--- /dev/null
+++ b/third_party/rules_rust/cargo/defs.bzl
@@ -0,0 +1,9 @@
+"""Common definitions for the `@rules_rust//cargo` package"""
+
+load(":cargo_bootstrap.bzl", _cargo_bootstrap_repository = "cargo_bootstrap_repository", _cargo_env = "cargo_env")
+load(":cargo_build_script.bzl", _cargo_build_script = "cargo_build_script")
+
+cargo_bootstrap_repository = _cargo_bootstrap_repository
+cargo_env = _cargo_env
+
+cargo_build_script = _cargo_build_script
diff --git a/third_party/rules_rust/cargo/private/BUILD.bazel b/third_party/rules_rust/cargo/private/BUILD.bazel
new file mode 100644
index 0000000..6a1aab6
--- /dev/null
+++ b/third_party/rules_rust/cargo/private/BUILD.bazel
@@ -0,0 +1,7 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+    visibility = ["//:__subpackages__"],
+)
diff --git a/third_party/rules_rust/cargo/private/cargo_utils.bzl b/third_party/rules_rust/cargo/private/cargo_utils.bzl
new file mode 100644
index 0000000..d519576
--- /dev/null
+++ b/third_party/rules_rust/cargo/private/cargo_utils.bzl
@@ -0,0 +1,193 @@
+"""Utility functions for the cargo rules"""
+
+load("//rust/platform:triple.bzl", "triple")
+load("//rust/platform:triple_mappings.bzl", "system_to_binary_ext")
+
+_CPU_ARCH_ERROR_MSG = """\
+Command failed with exit code '{code}': {args}
+----------stdout:
+{stdout}
+----------stderr:
+{stderr}
+"""
+
+def _query_cpu_architecture(repository_ctx, expected_archs, is_windows = False):
+    """Detect the host CPU architecture
+
+    Args:
+        repository_ctx (repository_ctx): The repository rule's context object
+        expected_archs (list): A list of expected architecture strings
+        is_windows (bool, optional): If true, the cpu lookup will use the windows method (`wmic` vs `uname`)
+
+    Returns:
+        str: The host's CPU architecture
+    """
+    if is_windows:
+        arguments = ["wmic", "os", "get", "osarchitecture"]
+    else:
+        arguments = ["uname", "-m"]
+
+    result = repository_ctx.execute(arguments)
+
+    if result.return_code:
+        fail(_CPU_ARCH_ERROR_MSG.format(
+            code = result.return_code,
+            args = arguments,
+            stdout = result.stdout,
+            stderr = result.stderr,
+        ))
+
+    if is_windows:
+        # Example output:
+        # OSArchitecture
+        # 64-bit
+        lines = result.stdout.split("\n")
+        arch = lines[1].strip()
+
+        # Translate 64-bit to a compatible rust platform
+        # https://doc.rust-lang.org/nightly/rustc/platform-support.html
+        if arch == "64-bit":
+            arch = "x86_64"
+    else:
+        arch = result.stdout.strip("\n")
+
+        # Correct the arm architecture for macos
+        if "mac" in repository_ctx.os.name and arch == "arm64":
+            arch = "aarch64"
+
+    if not arch in expected_archs:
+        fail("{} is not a expected cpu architecture {}\n{}".format(
+            arch,
+            expected_archs,
+            result.stdout,
+        ))
+
+    return arch
+
+def get_host_triple(repository_ctx, abi = None):
+    """Query host information for the appropriate triples for the crate_universe resolver
+
+    Args:
+        repository_ctx (repository_ctx): The rule's repository_ctx
+        abi (str): Since there's no consistent way to check for ABI, this info
+            may be explicitly provided
+
+    Returns:
+        struct: A triple struct, see `@rules_rust//rust/platform:triple.bzl`
+    """
+
+    # Detect the host's cpu architecture
+
+    supported_architectures = {
+        "linux": ["aarch64", "x86_64"],
+        "macos": ["aarch64", "x86_64"],
+        "windows": ["x86_64"],
+    }
+
+    if "linux" in repository_ctx.os.name:
+        cpu = _query_cpu_architecture(repository_ctx, supported_architectures["linux"])
+        return triple("{}-unknown-linux-{}".format(
+            cpu,
+            abi or "gnu",
+        ))
+
+    if "mac" in repository_ctx.os.name:
+        cpu = _query_cpu_architecture(repository_ctx, supported_architectures["macos"])
+        return triple("{}-apple-darwin".format(cpu))
+
+    if "win" in repository_ctx.os.name:
+        cpu = _query_cpu_architecture(repository_ctx, supported_architectures["windows"], True)
+        return triple("{}-pc-windows-{}".format(
+            cpu,
+            abi or "msvc",
+        ))
+
+    fail("Unhandled host os: {}", repository_ctx.os.name)
+
+def _resolve_repository_template(
+        template,
+        abi = None,
+        arch = None,
+        system = None,
+        tool = None,
+        triple = None,
+        vendor = None,
+        version = None):
+    """Render values into a repository template string
+
+    Args:
+        template (str): The template to use for rendering
+        abi (str, optional): The host ABI
+        arch (str, optional): The host CPU architecture
+        system (str, optional): The host system name
+        tool (str, optional): The tool to expect in the particular repository.
+            Eg. `cargo`, `rustc`, `stdlib`.
+        triple (str, optional): The host triple
+        vendor (str, optional): The host vendor name
+        version (str, optional): The Rust version used in the toolchain.
+    Returns:
+        string: The resolved template string based on the given parameters
+    """
+    if abi:
+        template = template.replace("{abi}", abi)
+
+    if arch:
+        template = template.replace("{arch}", arch)
+
+    if system:
+        template = template.replace("{system}", system)
+
+    if tool:
+        template = template.replace("{tool}", tool)
+
+    if triple:
+        template = template.replace("{triple}", triple)
+
+    if vendor:
+        template = template.replace("{vendor}", vendor)
+
+    if version:
+        template = template.replace("{version}", version)
+
+    return template
+
+def get_rust_tools(cargo_template, rustc_template, host_triple, version):
+    """Retrieve `cargo` and `rustc` labels based on the host triple.
+
+    Args:
+        cargo_template (str): A template used to identify the label of the host `cargo` binary.
+        rustc_template (str): A template used to identify the label of the host `rustc` binary.
+        host_triple (struct): The host's triple. See `@rules_rust//rust/platform:triple.bzl`.
+        version (str): The version of Cargo+Rustc to use.
+
+    Returns:
+        struct: A struct containing the labels of expected tools
+    """
+    extension = system_to_binary_ext(host_triple.system)
+
+    cargo_label = Label(_resolve_repository_template(
+        template = cargo_template,
+        version = version,
+        triple = host_triple.triple,
+        arch = host_triple.arch,
+        vendor = host_triple.vendor,
+        system = host_triple.system,
+        abi = host_triple.abi,
+        tool = "cargo" + extension,
+    ))
+
+    rustc_label = Label(_resolve_repository_template(
+        template = rustc_template,
+        version = version,
+        triple = host_triple.triple,
+        arch = host_triple.arch,
+        vendor = host_triple.vendor,
+        system = host_triple.system,
+        abi = host_triple.abi,
+        tool = "rustc" + extension,
+    ))
+
+    return struct(
+        cargo = cargo_label,
+        rustc = rustc_label,
+    )
diff --git a/third_party/rules_rust/crate_universe/3rdparty/BUILD.bazel b/third_party/rules_rust/crate_universe/3rdparty/BUILD.bazel
new file mode 100644
index 0000000..1f0b8ee
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/BUILD.bazel
@@ -0,0 +1,20 @@
+load("//crate_universe:crates.bzl", "crate_deps_target")
+
+package(default_visibility = ["//visibility:public"])
+
+crate_deps_target()
+
+filegroup(
+    name = "distro",
+    srcs = glob([
+        "*.bzl",
+        "*.bazel",
+    ]) + [
+        "//crate_universe/3rdparty/crates:srcs",
+    ],
+)
+
+filegroup(
+    name = "bzl_srcs",
+    srcs = glob(["*.bzl"]),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/BUILD.libgit2.bazel b/third_party/rules_rust/crate_universe/3rdparty/BUILD.libgit2.bazel
new file mode 100644
index 0000000..031ee78
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/BUILD.libgit2.bazel
@@ -0,0 +1,277 @@
+# This BUILD file was written based off of the `build.rs` script for the Rust
+# crate `libgit2-sys`. For more details, see the crate's source:
+# https://github.com/rust-lang/git2-rs/tree/libgit2-sys-0.13.0/libgit2-sys
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag")
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+[
+    config_setting(
+        name = plat,
+        constraint_values = ["@platforms//os:{}".format(plat)],
+    )
+    for plat in [
+        "macos",
+        "ios",
+        "tvos",
+        "windows",
+    ]
+]
+
+# env::var("CARGO_FEATURE_SSH").is_ok()
+bool_flag(
+    name = "ssh",
+    build_setting_default = False,
+)
+
+config_setting(
+    name = "ssh_setting",
+    flag_values = {":ssh": "True"},
+)
+
+# target.contains("apple")
+selects.config_setting_group(
+    name = "apple",
+    match_any = [
+        ":macos",
+        ":ios",
+        ":tvos",
+    ],
+)
+
+[
+    config_setting(
+        name = "cpu_" + cpu,
+        constraint_values = ["@platforms//cpu:{}".format(cpu)],
+    )
+    for cpu in [
+        "i386",
+        "x86_32",
+    ]
+]
+
+# env::var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap() == "32"
+selects.config_setting_group(
+    name = "pointer_width_32",
+    match_any = [
+        "cpu_i386",
+        "cpu_x86_32",
+    ],
+)
+
+# env::var("CARGO_FEATURE_HTTPS").is_ok()
+bool_flag(
+    name = "https",
+    build_setting_default = False,
+)
+
+config_setting(
+    name = "https_setting",
+    flag_values = {":https": "True"},
+)
+
+# if https && target.contains("windows")
+selects.config_setting_group(
+    name = "https_windows",
+    match_all = [
+        ":https_setting",
+        ":windows",
+    ],
+)
+
+# if https && target.contains("apple")
+selects.config_setting_group(
+    name = "https_apple",
+    match_all = [
+        ":https_setting",
+        ":apple",
+    ],
+)
+
+cc_library(
+    name = "http-parser",
+    srcs = glob(["deps/http-parser/*.c"]),
+    hdrs = glob(["deps/http-parser/*.h"]),
+    copts = select({
+        # Required in `opt` builds to solve the following error
+        # libpcre.a(pcre_compile.o): requires unsupported dynamic reloc 11; recompile with -fPIC
+        "@platforms//os:linux": ["-fPIC"],
+        "//conditions:default": [],
+    }),
+    includes = ["deps/http-parser"],
+    linkstatic = True,
+)
+
+cc_library(
+    name = "pcre",
+    srcs = glob(["deps/pcre/**/*.c"]),
+    hdrs = glob(["deps/pcre/**/*.h"]),
+    copts = select({
+        # Required in `opt` builds to solve the following error
+        # libhttp-parser.a(http_parser.o): requires unsupported dynamic reloc 11; recompile with -fPIC
+        "@platforms//os:linux": ["-fPIC"],
+        "//conditions:default": [],
+    }),
+    defines = [
+        "HAVE_STDINT_H=1",
+        "HAVE_MEMMOVE=1",
+        "NO_RECURSE=1",
+        "NEWLINE=10",
+        "POSIX_MALLOC_THRESHOLD=10",
+        "LINK_SIZE=2",
+        "PARENS_NEST_LIMIT=250",
+        "MATCH_LIMIT=10000000",
+        "MATCH_LIMIT_RECURSION=MATCH_LIMIT",
+        "MAX_NAME_SIZE=32",
+        "MAX_NAME_COUNT=10000",
+    ],
+    includes = ["deps/pcre"],
+    linkstatic = True,
+)
+
+write_file(
+    name = "configure_features",
+    out = "include/git2/sys/features.h",
+    content = [
+        "#ifndef INCLUDE_features_h",
+        "#define INCLUDE_features_h",
+        "#define GIT_THREADS 1",
+        "#define GIT_TRACE 1",
+    ] +
+    # !target.contains("android")
+    select({
+        "@platforms//os:android": [],
+        "//conditions:default": ["#define GIT_USE_NSEC 1"],
+    }) + select({
+        ":apple": ["#define GIT_USE_STAT_MTIMESPEC 1"],
+        "//conditions:default": ["#define GIT_USE_STAT_MTIM 1"],
+    }) + select({
+        ":pointer_width_32": ["#define GIT_ARCH_32 1"],
+        "//conditions:default": ["#define GIT_ARCH_64 1"],
+    }) + [
+        "#define GIT_SHA1_COLLISIONDETECT 1",
+    ] + select({
+        ":ssh_setting": ["#define GIT_SSH 1"],
+        "//conditions:default": [],
+    }) + select({
+        ":https_apple": [
+            "#define GIT_HTTPS 1",
+            "#define GIT_SECURE_TRANSPORT 1",
+        ],
+        ":https_setting": [
+            "#define GIT_HTTPS 1",
+            "#define GIT_OPENSSL 1",
+        ],
+        # target.contains("windows")
+        ":https_windows": [
+            "#define GIT_HTTPS 1",
+            "#define GIT_WINHTTP 1",
+        ],
+        "//conditions:default": [],
+    }) + select({
+        ":apple": ["#define GIT_USE_ICONV 1"],
+        "//conditions:default": [],
+    }) + [
+        "#endif",
+    ],
+)
+
+cc_library(
+    name = "git2",
+    srcs = glob(
+        include = [
+            "src/*.c",
+            "src/*.h",
+            "src/xdiff/*.h",
+            "src/xdiff/*.c",
+            "src/transports/*.h",
+            "src/transports/*.c",
+            "src/streams/*.h",
+            "src/streams/*.c",
+            "src/hash/*.h",
+            "src/hash/*.c",
+        ],
+        exclude = [
+            "src/win32/**",
+            "src/unix/**",
+        ],
+    ) + select({
+        "@platforms//os:windows": glob([
+            "src/win32/**/*.h",
+            "src/win32/**/*.c",
+        ]),
+        "//conditions:default": glob([
+            "src/unix/**/*.h",
+            "src/unix/**/*.c",
+        ]),
+    }) + [
+        "src/allocators/failalloc.c",
+        "src/allocators/failalloc.h",
+        "src/allocators/stdalloc.c",
+        "src/allocators/stdalloc.h",
+        "src/allocators/win32_leakcheck.c",
+        "src/allocators/win32_leakcheck.h",
+        # Use the CollisionDetection SHA1 implementation.
+        "src/hash/sha1/collisiondetect.h",
+        "src/hash/sha1/collisiondetect.c",
+        "src/hash/sha1/sha1dc/sha1.h",
+        "src/hash/sha1/sha1dc/sha1.c",
+        "src/hash/sha1/sha1dc/ubc_check.h",
+        "src/hash/sha1/sha1dc/ubc_check.c",
+    ],
+    hdrs = glob(["include/**/*.h"]) + [
+        ":configure_features",
+    ],
+    copts = select({
+        "@platforms//os:linux": [
+            "-fvisibility=hidden",
+            "-fPIC",
+            "-Wall",
+            "-std=gnu90",
+            # On linux, optimization is required to avoid issues with missing (and unused) symbols:
+            # `liblibgit2.a(pack.pic.o):pack.c:function packfile_open_locked: error: undefined reference to 'fstat'`
+            #
+            # Always enabling optimization helps us avoid this though, it does seem unnecessary and this should
+            # probably be fixed.
+            "-O3",
+        ],
+        "@platforms//os:windows": [],
+        "//conditions:default": [
+            "-fvisibility=hidden",
+            "-fPIC",
+            "-Wall",
+            "-std=gnu90",
+        ],
+    }),
+    defines = [
+        # Use the CollisionDetection SHA1 implementation.
+        "SHA1DC_NO_STANDARD_INCLUDES=1",
+        "SHA1DC_CUSTOM_INCLUDE_SHA1_C=\\\"common.h\\\"",
+        "SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C=\\\"common.h\\\"",
+        # Use the included PCRE regex backend.
+        "GIT_REGEX_BUILTIN=1",
+    ] + select({
+        ":windows": ["STRSAFE_NO_DEPRECATE"],
+        "//conditions:default": [],
+    }),
+    includes = [
+        "include",
+        "src",
+    ],
+    linkstatic = True,
+    strip_include_prefix = "include",
+    visibility = ["//visibility:public"],
+    deps = [
+        ":http-parser",
+        ":pcre",
+        "@zlib",
+    ],
+)
+
+alias(
+    name = "libgit2",
+    actual = ":git2",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/BUILD.zlib.bazel b/third_party/rules_rust/crate_universe/3rdparty/BUILD.zlib.bazel
new file mode 100644
index 0000000..dbf8452
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/BUILD.zlib.bazel
@@ -0,0 +1,25 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "zlib",
+    srcs = glob(["*.c"]),
+    hdrs = glob(["*.h"]),
+    # Use -Dverbose=-1 to turn off zlib's trace logging.
+    # https://github.com/bazelbuild/bazel/issues/3280
+    copts = select({
+        "@platforms//os:linux": [
+            "-w",
+            "-Dverbose=-1",
+            # Required for opt builds to avoid
+            # `libzlib.a(crc32.o): requires unsupported dynamic reloc 11; recompile with -fPIC`
+            "-fPIC",
+        ],
+        "//conditions:default": [
+            "-w",
+            "-Dverbose=-1",
+        ],
+    }),
+    includes = ["."],
+    linkstatic = True,
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.aho-corasick-0.7.18.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.aho-corasick-0.7.18.bazel
new file mode 100644
index 0000000..461d2ac
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.aho-corasick-0.7.18.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "aho_corasick",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.18",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__memchr-2.4.1//:memchr",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.anyhow-1.0.55.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.anyhow-1.0.55.bazel
new file mode 100644
index 0000000..862e2f4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.anyhow-1.0.55.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "anyhow",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.55",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__anyhow-1.0.55//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "anyhow_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.55",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "anyhow_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.atty-0.2.14.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.atty-0.2.14.bazel
new file mode 100644
index 0000000..da6f0b6
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.atty-0.2.14.bazel
@@ -0,0 +1,124 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "atty",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.14",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "hermit")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "hermit")'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.autocfg-1.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.autocfg-1.1.0.bazel
new file mode 100644
index 0000000..bd2fcd9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.autocfg-1.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bazel
new file mode 100644
index 0000000..4f6b676
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bazel
@@ -0,0 +1,166 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+        "crates.bzl",
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+alias(
+    name = "anyhow",
+    actual = "@crate_index__anyhow-1.0.55//:anyhow",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cargo-lock",
+    actual = "@crate_index__cargo-lock-7.0.1//:cargo_lock",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cargo-platform",
+    actual = "@crate_index__cargo-platform-0.1.2//:cargo_platform",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cargo_metadata",
+    actual = "@crate_index__cargo_metadata-0.14.2//:cargo_metadata",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cargo_toml",
+    actual = "@crate_index__cargo_toml-0.11.4//:cargo_toml",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cfg-expr",
+    actual = "@crate_index__cfg-expr-0.10.2//:cfg_expr",
+    tags = ["manual"],
+)
+
+alias(
+    name = "clap",
+    actual = "@crate_index__clap-3.1.5//:clap",
+    tags = ["manual"],
+)
+
+alias(
+    name = "crates-index",
+    actual = "@crate_index__crates-index-0.18.7//:crates_index",
+    tags = ["manual"],
+)
+
+alias(
+    name = "hex",
+    actual = "@crate_index__hex-0.4.3//:hex",
+    tags = ["manual"],
+)
+
+alias(
+    name = "pathdiff",
+    actual = "@crate_index__pathdiff-0.2.1//:pathdiff",
+    tags = ["manual"],
+)
+
+alias(
+    name = "regex",
+    actual = "@crate_index__regex-1.5.4//:regex",
+    tags = ["manual"],
+)
+
+alias(
+    name = "semver",
+    actual = "@crate_index__semver-1.0.6//:semver",
+    tags = ["manual"],
+)
+
+alias(
+    name = "serde",
+    actual = "@crate_index__serde-1.0.136//:serde",
+    tags = ["manual"],
+)
+
+alias(
+    name = "serde_json",
+    actual = "@crate_index__serde_json-1.0.79//:serde_json",
+    tags = ["manual"],
+)
+
+alias(
+    name = "sha2",
+    actual = "@crate_index__sha2-0.10.2//:sha2",
+    tags = ["manual"],
+)
+
+alias(
+    name = "spectral",
+    actual = "@crate_index__spectral-0.6.0//:spectral",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tempfile",
+    actual = "@crate_index__tempfile-3.3.0//:tempfile",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tera",
+    actual = "@crate_index__tera-1.15.0//:tera",
+    tags = ["manual"],
+)
+
+alias(
+    name = "textwrap",
+    actual = "@crate_index__textwrap-0.14.2//:textwrap",
+    tags = ["manual"],
+)
+
+alias(
+    name = "toml",
+    actual = "@crate_index__toml-0.5.8//:toml",
+    tags = ["manual"],
+)
+
+# Binaries
+alias(
+    name = "cargo-lock__cargo-lock",
+    actual = "@crate_index__cargo-lock-7.0.1//:cargo-lock__bin",
+    tags = ["manual"],
+)
+
+alias(
+    name = "cc__gcc-shim",
+    actual = "@crate_index__cc-1.0.73//:gcc-shim__bin",
+    tags = ["manual"],
+)
+
+alias(
+    name = "phf_generator__gen_hash_test",
+    actual = "@crate_index__phf_generator-0.10.0//:gen_hash_test__bin",
+    tags = ["manual"],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bitflags-1.3.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bitflags-1.3.2.bazel
new file mode 100644
index 0000000..6894746
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bitflags-1.3.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.10.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.10.2.bazel
new file mode 100644
index 0000000..5937127
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.10.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "block_buffer",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__generic-array-0.14.5//:generic_array",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.7.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.7.3.bazel
new file mode 100644
index 0000000..1bb6977
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-buffer-0.7.3.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "block_buffer",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__block-padding-0.1.5//:block_padding",
+            "@crate_index__byte-tools-0.3.1//:byte_tools",
+            "@crate_index__byteorder-1.4.3//:byteorder",
+            "@crate_index__generic-array-0.12.4//:generic_array",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-padding-0.1.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-padding-0.1.5.bazel
new file mode 100644
index 0000000..57a82a0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.block-padding-0.1.5.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "block_padding",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.5",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__byte-tools-0.3.1//:byte_tools",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bstr-0.2.17.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bstr-0.2.17.bazel
new file mode 100644
index 0000000..49bc9e9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.bstr-0.2.17.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "bstr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.17",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__memchr-2.4.1//:memchr",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byte-tools-0.3.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byte-tools-0.3.1.bazel
new file mode 100644
index 0000000..c4f77ba
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byte-tools-0.3.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "byte_tools",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byteorder-1.4.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byteorder-1.4.3.bazel
new file mode 100644
index 0000000..d08f7c4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.byteorder-1.4.3.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense OR MIT
+# ])
+
+rust_library(
+    name = "byteorder",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.camino-1.0.7.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.camino-1.0.7.bazel
new file mode 100644
index 0000000..4a616b6
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.camino-1.0.7.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "camino",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "serde",
+        "serde1",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__camino-1.0.7//:build_script_build",
+            "@crate_index__serde-1.0.136//:serde",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "camino_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "serde",
+        "serde1",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "camino_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-lock-7.0.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-lock-7.0.1.bazel
new file mode 100644
index 0000000..df635c5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-lock-7.0.1.bazel
@@ -0,0 +1,154 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "cargo_lock",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "7.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__semver-1.0.6//:semver",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__toml-0.5.8//:toml",
+            "@crate_index__url-2.2.2//:url",
+        ],
+    }),
+)
+
+rust_binary(
+    name = "cargo-lock__bin",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/bin/cargo-lock/main.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "7.0.1",
+    deps = [
+        ":cargo_lock",
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__semver-1.0.6//:semver",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__toml-0.5.8//:toml",
+            "@crate_index__url-2.2.2//:url",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-platform-0.1.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-platform-0.1.2.bazel
new file mode 100644
index 0000000..27eded2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo-platform-0.1.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "cargo_platform",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:serde",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_metadata-0.14.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_metadata-0.14.2.bazel
new file mode 100644
index 0000000..0255882
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_metadata-0.14.2.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "cargo_metadata",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__camino-1.0.7//:camino",
+            "@crate_index__cargo-platform-0.1.2//:cargo_platform",
+            "@crate_index__semver-1.0.6//:semver",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__serde_json-1.0.79//:serde_json",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_toml-0.11.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_toml-0.11.4.bazel
new file mode 100644
index 0000000..3a26aab
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cargo_toml-0.11.4.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "cargo_toml",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/cargo_toml.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde_derive-1.0.136//:serde_derive",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__toml-0.5.8//:toml",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cc-1.0.73.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cc-1.0.73.bazel
new file mode 100644
index 0000000..70e0555
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cc-1.0.73.bazel
@@ -0,0 +1,152 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "jobserver",
+        "parallel",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.73",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__jobserver-0.1.24//:jobserver",
+        ],
+    }),
+)
+
+rust_binary(
+    name = "gcc-shim__bin",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "jobserver",
+        "parallel",
+    ],
+    crate_root = "src/bin/gcc-shim.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.73",
+    deps = [
+        ":cc",
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__jobserver-0.1.24//:jobserver",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-expr-0.10.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-expr-0.10.2.bazel
new file mode 100644
index 0000000..7f578b2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-expr-0.10.2.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_expr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__smallvec-1.8.0//:smallvec",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..e4aab64
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-0.4.19.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-0.4.19.bazel
new file mode 100644
index 0000000..a28b567
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-0.4.19.bazel
@@ -0,0 +1,104 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "chrono",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clock",
+        "libc",
+        "std",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.19",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crate_index__libc-0.2.119//:libc",
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+        ],
+        "//conditions:default": [
+            "@crate_index__libc-0.2.119//:libc",
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-0.6.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-0.6.1.bazel
new file mode 100644
index 0000000..9fe3d72
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-0.6.1.bazel
@@ -0,0 +1,178 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "chrono_tz",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__chrono-0.4.19//:chrono",
+            "@crate_index__chrono-tz-0.6.1//:build_script_build",
+            "@crate_index__phf-0.10.1//:phf",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "chrono-tz_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.6.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__chrono-tz-build-0.0.2//:chrono_tz_build",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "chrono-tz_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-build-0.0.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-build-0.0.2.bazel
new file mode 100644
index 0000000..ff11da9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.chrono-tz-build-0.0.2.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "chrono_tz_build",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.0.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__parse-zoneinfo-0.3.0//:parse_zoneinfo",
+            "@crate_index__phf-0.10.1//:phf",
+            "@crate_index__phf_codegen-0.10.0//:phf_codegen",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap-3.1.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap-3.1.5.bazel
new file mode 100644
index 0000000..288246b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap-3.1.5.bazel
@@ -0,0 +1,104 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "clap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "atty",
+        "clap_derive",
+        "color",
+        "default",
+        "derive",
+        "env",
+        "lazy_static",
+        "std",
+        "strsim",
+        "suggestions",
+        "termcolor",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__clap_derive-3.1.4//:clap_derive",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "3.1.5",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__atty-0.2.14//:atty",
+            "@crate_index__bitflags-1.3.2//:bitflags",
+            "@crate_index__indexmap-1.8.0//:indexmap",
+            "@crate_index__lazy_static-1.4.0//:lazy_static",
+            "@crate_index__os_str_bytes-6.0.0//:os_str_bytes",
+            "@crate_index__strsim-0.10.0//:strsim",
+            "@crate_index__termcolor-1.1.3//:termcolor",
+            "@crate_index__textwrap-0.15.0//:textwrap",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap_derive-3.1.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap_derive-3.1.4.bazel
new file mode 100644
index 0000000..be1c87c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.clap_derive-3.1.4.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "clap_derive",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "3.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__heck-0.4.0//:heck",
+            "@crate_index__proc-macro-error-1.0.4//:proc_macro_error",
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+            "@crate_index__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cpufeatures-0.2.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cpufeatures-0.2.1.bazel
new file mode 100644
index 0000000..c9f420c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.cpufeatures-0.2.1.bazel
@@ -0,0 +1,102 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "cpufeatures",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.1",
+    deps = [
+    ] + select_with_or({
+        # aarch64-apple-darwin
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        # cfg(all(target_arch = "aarch64", target_os = "linux"))
+        (
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crates-index-0.18.7.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crates-index-0.18.7.bazel
new file mode 100644
index 0000000..085bbd5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crates-index-0.18.7.bazel
@@ -0,0 +1,95 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0
+# ])
+
+rust_library(
+    name = "crates_index",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde_derive-1.0.136//:serde_derive",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.18.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__git2-0.14.1//:git2",
+            "@crate_index__hex-0.4.3//:hex",
+            "@crate_index__home-0.5.3//:home",
+            "@crate_index__memchr-2.4.1//:memchr",
+            "@crate_index__num_cpus-1.13.1//:num_cpus",
+            "@crate_index__rustc-hash-1.1.0//:rustc_hash",
+            "@crate_index__semver-1.0.6//:semver",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__serde_json-1.0.79//:serde_json",
+            "@crate_index__smartstring-1.0.0//:smartstring",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crossbeam-utils-0.8.7.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crossbeam-utils-0.8.7.bazel
new file mode 100644
index 0000000..228b9ea
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crossbeam-utils-0.8.7.bazel
@@ -0,0 +1,179 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "crossbeam_utils",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__crossbeam-utils-0.8.7//:build_script_build",
+            "@crate_index__lazy_static-1.4.0//:lazy_static",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "crossbeam-utils_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.8.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "crossbeam-utils_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crypto-common-0.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crypto-common-0.1.3.bazel
new file mode 100644
index 0000000..269f2d8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.crypto-common-0.1.3.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "crypto_common",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__generic-array-0.14.5//:generic_array",
+            "@crate_index__typenum-1.15.0//:typenum",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.deunicode-0.4.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.deunicode-0.4.3.bazel
new file mode 100644
index 0000000..dbea22a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.deunicode-0.4.3.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "deunicode",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.10.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.10.3.bazel
new file mode 100644
index 0000000..0566635
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.10.3.bazel
@@ -0,0 +1,91 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "digest",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "block-buffer",
+        "core-api",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__block-buffer-0.10.2//:block_buffer",
+            "@crate_index__crypto-common-0.1.3//:crypto_common",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.8.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.8.1.bazel
new file mode 100644
index 0000000..ffcb916
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.digest-0.8.1.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "digest",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__generic-array-0.12.4//:generic_array",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fake-simd-0.1.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fake-simd-0.1.2.bazel
new file mode 100644
index 0000000..b5f46a2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fake-simd-0.1.2.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "fake_simd",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fastrand-1.7.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fastrand-1.7.0.bazel
new file mode 100644
index 0000000..4653164
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fastrand-1.7.0.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "fastrand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_arch = "wasm32")
+        (
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            # Target Deps
+            "@crate_index__instant-0.1.12//:instant",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fnv-1.0.7.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fnv-1.0.7.bazel
new file mode 100644
index 0000000..9b3c6e3
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fnv-1.0.7.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 / MIT
+# ])
+
+rust_library(
+    name = "fnv",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.form_urlencoded-1.0.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.form_urlencoded-1.0.1.bazel
new file mode 100644
index 0000000..55ca7b5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.form_urlencoded-1.0.1.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "form_urlencoded",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__matches-0.1.9//:matches",
+            "@crate_index__percent-encoding-2.1.0//:percent_encoding",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fuchsia-cprng-0.1.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fuchsia-cprng-0.1.1.bazel
new file mode 100644
index 0000000..13c5d65
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.fuchsia-cprng-0.1.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  #
+# ])
+
+rust_library(
+    name = "fuchsia_cprng",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.12.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.12.4.bazel
new file mode 100644
index 0000000..34536b7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.12.4.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "generic_array",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.12.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__typenum-1.15.0//:typenum",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.14.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.14.5.bazel
new file mode 100644
index 0000000..9d7fc09
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.generic-array-0.14.5.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "generic_array",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "more_lengths",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.5",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__generic-array-0.14.5//:build_script_build",
+            "@crate_index__typenum-1.15.0//:typenum",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "generic-array_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "more_lengths",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.14.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__version_check-0.9.4//:version_check",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "generic-array_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.getrandom-0.2.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.getrandom-0.2.5.bazel
new file mode 100644
index 0000000..0c73b2d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.getrandom-0.2.5.bazel
@@ -0,0 +1,122 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "getrandom",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "wasi")
+        (
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            # Target Deps
+            "@crate_index__wasi-0.10.2-wasi-snapshot-preview1//:wasi",
+
+            # Common Deps
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+        ],
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+        ],
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.git2-0.14.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.git2-0.14.1.bazel
new file mode 100644
index 0000000..1a3d468
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.git2-0.14.1.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "git2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__bitflags-1.3.2//:bitflags",
+            "@crate_index__libc-0.2.119//:libc",
+            "@crate_index__libgit2-sys-0.13.1-1.4.2//:libgit2_sys",
+            "@crate_index__log-0.4.14//:log",
+            "@crate_index__url-2.2.2//:url",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globset-0.4.8.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globset-0.4.8.bazel
new file mode 100644
index 0000000..e38b033
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globset-0.4.8.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "globset",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__aho-corasick-0.7.18//:aho_corasick",
+            "@crate_index__bstr-0.2.17//:bstr",
+            "@crate_index__fnv-1.0.7//:fnv",
+            "@crate_index__log-0.4.14//:log",
+            "@crate_index__regex-1.5.4//:regex",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globwalk-0.8.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globwalk-0.8.1.bazel
new file mode 100644
index 0000000..f66d00a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.globwalk-0.8.1.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "globwalk",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__bitflags-1.3.2//:bitflags",
+            "@crate_index__ignore-0.4.18//:ignore",
+            "@crate_index__walkdir-2.3.2//:walkdir",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hashbrown-0.11.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hashbrown-0.11.2.bazel
new file mode 100644
index 0000000..54a071b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hashbrown-0.11.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "hashbrown",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "raw",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.heck-0.4.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.heck-0.4.0.bazel
new file mode 100644
index 0000000..f8a2a8e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.heck-0.4.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "heck",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hermit-abi-0.1.19.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hermit-abi-0.1.19.bazel
new file mode 100644
index 0000000..87a0e63
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hermit-abi-0.1.19.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hex-0.4.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hex-0.4.3.bazel
new file mode 100644
index 0000000..532d6eb
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.hex-0.4.3.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "hex",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "serde",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:serde",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.home-0.5.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.home-0.5.3.bazel
new file mode 100644
index 0000000..d500a98
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.home-0.5.3.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "home",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.5.3",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.humansize-1.1.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.humansize-1.1.1.bazel
new file mode 100644
index 0000000..48be3d7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.humansize-1.1.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "humansize",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.idna-0.2.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.idna-0.2.3.bazel
new file mode 100644
index 0000000..d414d18
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.idna-0.2.3.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "idna",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__matches-0.1.9//:matches",
+            "@crate_index__unicode-bidi-0.3.7//:unicode_bidi",
+            "@crate_index__unicode-normalization-0.1.19//:unicode_normalization",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ignore-0.4.18.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ignore-0.4.18.bazel
new file mode 100644
index 0000000..3d8cc4b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ignore-0.4.18.bazel
@@ -0,0 +1,112 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "ignore",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.18",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-util-0.1.5//:winapi_util",
+
+            # Common Deps
+            "@crate_index__crossbeam-utils-0.8.7//:crossbeam_utils",
+            "@crate_index__globset-0.4.8//:globset",
+            "@crate_index__lazy_static-1.4.0//:lazy_static",
+            "@crate_index__log-0.4.14//:log",
+            "@crate_index__memchr-2.4.1//:memchr",
+            "@crate_index__regex-1.5.4//:regex",
+            "@crate_index__same-file-1.0.6//:same_file",
+            "@crate_index__thread_local-1.1.4//:thread_local",
+            "@crate_index__walkdir-2.3.2//:walkdir",
+        ],
+        "//conditions:default": [
+            "@crate_index__crossbeam-utils-0.8.7//:crossbeam_utils",
+            "@crate_index__globset-0.4.8//:globset",
+            "@crate_index__lazy_static-1.4.0//:lazy_static",
+            "@crate_index__log-0.4.14//:log",
+            "@crate_index__memchr-2.4.1//:memchr",
+            "@crate_index__regex-1.5.4//:regex",
+            "@crate_index__same-file-1.0.6//:same_file",
+            "@crate_index__thread_local-1.1.4//:thread_local",
+            "@crate_index__walkdir-2.3.2//:walkdir",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.indexmap-1.8.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.indexmap-1.8.0.bazel
new file mode 100644
index 0000000..18e7ed7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.indexmap-1.8.0.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "indexmap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__hashbrown-0.11.2//:hashbrown",
+            "@crate_index__indexmap-1.8.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "indexmap_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.8.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__autocfg-1.1.0//:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "indexmap_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.instant-0.1.12.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.instant-0.1.12.bazel
new file mode 100644
index 0000000..97683a6
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.instant-0.1.12.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "instant",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.itoa-1.0.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.itoa-1.0.1.bazel
new file mode 100644
index 0000000..69bfcf9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.itoa-1.0.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "itoa",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.jobserver-0.1.24.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.jobserver-0.1.24.bazel
new file mode 100644
index 0000000..6e08f26
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.jobserver-0.1.24.bazel
@@ -0,0 +1,109 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "jobserver",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.24",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..aabde66
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libc-0.2.119.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libc-0.2.119.bazel
new file mode 100644
index 0000000..57c96d1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libc-0.2.119.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.119",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__libc-0.2.119//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "libc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.119",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "libc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libgit2-sys-0.13.1+1.4.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libgit2-sys-0.13.1+1.4.2.bazel
new file mode 100644
index 0000000..1f86220
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libgit2-sys-0.13.1+1.4.2.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "libgit2_sys",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.13.1+1.4.2",
+    deps = [
+        "@libgit2",
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__libc-0.2.119//:libc",
+            "@crate_index__libz-sys-1.1.3//:libz_sys",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libz-sys-1.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libz-sys-1.1.3.bazel
new file mode 100644
index 0000000..725a428
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.libz-sys-1.1.3.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libz_sys",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "libc",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.3",
+    deps = [
+        "@zlib",
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.log-0.4.14.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..6471f8d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.log-0.4.14.bazel
@@ -0,0 +1,172 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__log-0.4.14//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "log_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "log_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.maplit-1.0.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.maplit-1.0.2.bazel
new file mode 100644
index 0000000..c7e2e04
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.maplit-1.0.2.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "maplit",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.matches-0.1.9.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.matches-0.1.9.bazel
new file mode 100644
index 0000000..b2ec92b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.matches-0.1.9.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "matches",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..ae3c518
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "memchr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.4.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__memchr-2.4.1//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "memchr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "memchr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-0.1.42.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-0.1.42.bazel
new file mode 100644
index 0000000..e64c7e9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-0.1.42.bazel
@@ -0,0 +1,98 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "num",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bigint",
+        "complex",
+        "default",
+        "num-bigint",
+        "num-complex",
+        "num-rational",
+        "rational",
+        "rustc-serialize",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.42",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-bigint-0.1.44//:num_bigint",
+            "@crate_index__num-complex-0.1.43//:num_complex",
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-iter-0.1.42//:num_iter",
+            "@crate_index__num-rational-0.1.42//:num_rational",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-bigint-0.1.44.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-bigint-0.1.44.bazel
new file mode 100644
index 0000000..861ff69
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-bigint-0.1.44.bazel
@@ -0,0 +1,91 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "num_bigint",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "rand",
+        "rustc-serialize",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.44",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+            "@crate_index__rand-0.4.6//:rand",
+            "@crate_index__rustc-serialize-0.3.24//:rustc_serialize",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-complex-0.1.43.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-complex-0.1.43.bazel
new file mode 100644
index 0000000..07ee208
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-complex-0.1.43.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "num_complex",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "rustc-serialize",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.43",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-traits-0.2.14//:num_traits",
+            "@crate_index__rustc-serialize-0.3.24//:rustc_serialize",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-integer-0.1.44.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-integer-0.1.44.bazel
new file mode 100644
index 0000000..b8e125d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-integer-0.1.44.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_integer",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.44",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-integer-0.1.44//:build_script_build",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "num-integer_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.44",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__autocfg-1.1.0//:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "num-integer_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-iter-0.1.42.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-iter-0.1.42.bazel
new file mode 100644
index 0000000..926481a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-iter-0.1.42.bazel
@@ -0,0 +1,178 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_iter",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.42",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-iter-0.1.42//:build_script_build",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "num-iter_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.42",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__autocfg-1.1.0//:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "num-iter_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-rational-0.1.42.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-rational-0.1.42.bazel
new file mode 100644
index 0000000..1b3ca21
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-rational-0.1.42.bazel
@@ -0,0 +1,92 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "num_rational",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bigint",
+        "default",
+        "num-bigint",
+        "rustc-serialize",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.42",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-bigint-0.1.44//:num_bigint",
+            "@crate_index__num-integer-0.1.44//:num_integer",
+            "@crate_index__num-traits-0.2.14//:num_traits",
+            "@crate_index__rustc-serialize-0.3.24//:rustc_serialize",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-traits-0.2.14.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-traits-0.2.14.bazel
new file mode 100644
index 0000000..0b5ebe1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num-traits-0.2.14.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_traits",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-traits-0.2.14//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "num-traits_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__autocfg-1.1.0//:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "num-traits_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num_cpus-1.13.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num_cpus-1.13.1.bazel
new file mode 100644
index 0000000..9cb3763
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.num_cpus-1.13.1.bazel
@@ -0,0 +1,116 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.13.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))
+        #
+        # No supported platform triples for cfg: 'cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.once_cell-1.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.once_cell-1.9.0.bazel
new file mode 100644
index 0000000..f2a936a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.once_cell-1.9.0.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "once_cell",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "race",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.opaque-debug-0.2.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.opaque-debug-0.2.3.bazel
new file mode 100644
index 0000000..f327831
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.opaque-debug-0.2.3.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "opaque_debug",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.os_str_bytes-6.0.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.os_str_bytes-6.0.0.bazel
new file mode 100644
index 0000000..10bd190
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.os_str_bytes-6.0.0.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "os_str_bytes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "memchr",
+        "raw_os_str",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "6.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__memchr-2.4.1//:memchr",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.parse-zoneinfo-0.3.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.parse-zoneinfo-0.3.0.bazel
new file mode 100644
index 0000000..f825ee1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.parse-zoneinfo-0.3.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "parse_zoneinfo",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__regex-1.5.4//:regex",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pathdiff-0.2.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pathdiff-0.2.1.bazel
new file mode 100644
index 0000000..4aade08
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pathdiff-0.2.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "pathdiff",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.percent-encoding-2.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.percent-encoding-2.1.0.bazel
new file mode 100644
index 0000000..1ad467a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.percent-encoding-2.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "percent_encoding",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest-2.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest-2.1.3.bazel
new file mode 100644
index 0000000..47afac4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest-2.1.3.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "pest",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__ucd-trie-0.1.3//:ucd_trie",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_derive-2.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_derive-2.1.0.bazel
new file mode 100644
index 0000000..53c8c15
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_derive-2.1.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "pest_derive",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__pest-2.1.3//:pest",
+            "@crate_index__pest_generator-2.1.3//:pest_generator",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_generator-2.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_generator-2.1.3.bazel
new file mode 100644
index 0000000..1370e95
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_generator-2.1.3.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "pest_generator",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__pest-2.1.3//:pest",
+            "@crate_index__pest_meta-2.1.3//:pest_meta",
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+            "@crate_index__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_meta-2.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_meta-2.1.3.bazel
new file mode 100644
index 0000000..81b94ca
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pest_meta-2.1.3.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "pest_meta",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__maplit-1.0.2//:maplit",
+            "@crate_index__pest-2.1.3//:pest",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf-0.10.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf-0.10.1.bazel
new file mode 100644
index 0000000..567ec45
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf-0.10.1.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "phf",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "uncased",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__phf_shared-0.10.0//:phf_shared",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_codegen-0.10.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_codegen-0.10.0.bazel
new file mode 100644
index 0000000..7d8a09f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_codegen-0.10.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "phf_codegen",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__phf_generator-0.10.0//:phf_generator",
+            "@crate_index__phf_shared-0.10.0//:phf_shared",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_generator-0.10.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_generator-0.10.0.bazel
new file mode 100644
index 0000000..2399789
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_generator-0.10.0.bazel
@@ -0,0 +1,150 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "phf_generator",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__phf_shared-0.10.0//:phf_shared",
+            "@crate_index__rand-0.8.5//:rand",
+        ],
+    }),
+)
+
+rust_binary(
+    name = "gen_hash_test__bin",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/bin/gen_hash_test.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.0",
+    deps = [
+        ":phf_generator",
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__phf_shared-0.10.0//:phf_shared",
+            "@crate_index__rand-0.8.5//:rand",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_shared-0.10.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_shared-0.10.0.bazel
new file mode 100644
index 0000000..ff6ae0c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.phf_shared-0.10.0.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "phf_shared",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+        "uncased",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__siphasher-0.3.9//:siphasher",
+            "@crate_index__uncased-0.9.6//:uncased",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pkg-config-0.3.24.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pkg-config-0.3.24.bazel
new file mode 100644
index 0000000..d0f2e51
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.pkg-config-0.3.24.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "pkg_config",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.24",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ppv-lite86-0.2.16.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ppv-lite86-0.2.16.bazel
new file mode 100644
index 0000000..f93bf68
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ppv-lite86-0.2.16.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "ppv_lite86",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "simd",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.16",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-1.0.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-1.0.4.bazel
new file mode 100644
index 0000000..234edf1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-1.0.4.bazel
@@ -0,0 +1,182 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro_error",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "syn",
+        "syn-error",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro-error-attr-1.0.4//:proc_macro_error_attr",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro-error-1.0.4//:build_script_build",
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+            "@crate_index__syn-1.0.86//:syn",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro-error_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "syn",
+        "syn-error",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.4",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__version_check-0.9.4//:version_check",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro-error_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-attr-1.0.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-attr-1.0.4.bazel
new file mode 100644
index 0000000..5753e76
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro-error-attr-1.0.4.bazel
@@ -0,0 +1,174 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "proc_macro_error_attr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro-error-attr-1.0.4//:build_script_build",
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro-error-attr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.4",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__version_check-0.9.4//:version_check",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro-error-attr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro2-1.0.36.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro2-1.0.36.bazel
new file mode 100644
index 0000000..7b9e4c2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.proc-macro2-1.0.36.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.36",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro2-1.0.36//:build_script_build",
+            "@crate_index__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro2_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.36",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro2_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.quote-1.0.15.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.quote-1.0.15.bazel
new file mode 100644
index 0000000..da83b59
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.quote-1.0.15.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "quote",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.4.6.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.4.6.bazel
new file mode 100644
index 0000000..fd20593
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.4.6.bazel
@@ -0,0 +1,132 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "rand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "libc",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_env = "sgx")
+        #
+        # No supported platform triples for cfg: 'cfg(target_env = "sgx")'
+        # Skipped dependencies: [{"id":"rand_core 0.3.1","target":"rand_core"},{"id":"rdrand 0.4.0","target":"rdrand"}]
+        #
+        # cfg(target_os = "fuchsia")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "fuchsia")'
+        # Skipped dependencies: [{"id":"fuchsia-cprng 0.1.1","target":"fuchsia_cprng"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.8.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.8.5.bazel
new file mode 100644
index 0000000..33dfcf8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand-0.8.5.bazel
@@ -0,0 +1,121 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "rand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "getrandom",
+        "libc",
+        "rand_chacha",
+        "small_rng",
+        "std",
+        "std_rng",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crate_index__rand_chacha-0.3.1//:rand_chacha",
+            "@crate_index__rand_core-0.6.3//:rand_core",
+        ],
+        "//conditions:default": [
+            "@crate_index__rand_chacha-0.3.1//:rand_chacha",
+            "@crate_index__rand_core-0.6.3//:rand_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_chacha-0.3.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_chacha-0.3.1.bazel
new file mode 100644
index 0000000..b6eab72
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_chacha-0.3.1.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "rand_chacha",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__ppv-lite86-0.2.16//:ppv_lite86",
+            "@crate_index__rand_core-0.6.3//:rand_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.3.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.3.1.bazel
new file mode 100644
index 0000000..3be752f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.3.1.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "rand_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__rand_core-0.4.2//:rand_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.4.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.4.2.bazel
new file mode 100644
index 0000000..d835c72
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.4.2.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "rand_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.6.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.6.3.bazel
new file mode 100644
index 0000000..ac7f43b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rand_core-0.6.3.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "rand_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "getrandom",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__getrandom-0.2.5//:getrandom",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rdrand-0.4.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rdrand-0.4.0.bazel
new file mode 100644
index 0000000..16c3ff5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rdrand-0.4.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # ISC
+# ])
+
+rust_library(
+    name = "rdrand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__rand_core-0.3.1//:rand_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.redox_syscall-0.2.11.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.redox_syscall-0.2.11.bazel
new file mode 100644
index 0000000..d06e9f0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.redox_syscall-0.2.11.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "syscall",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__bitflags-1.3.2//:bitflags",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-1.5.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-1.5.4.bazel
new file mode 100644
index 0000000..da772c0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-1.5.4.bazel
@@ -0,0 +1,104 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "regex",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.5.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__aho-corasick-0.7.18//:aho_corasick",
+            "@crate_index__memchr-2.4.1//:memchr",
+            "@crate_index__regex-syntax-0.6.25//:regex_syntax",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-syntax-0.6.25.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-syntax-0.6.25.bazel
new file mode 100644
index 0000000..8cd2b0b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.regex-syntax-0.6.25.bazel
@@ -0,0 +1,93 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "regex_syntax",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.25",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.remove_dir_all-0.5.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.remove_dir_all-0.5.3.bazel
new file mode 100644
index 0000000..11007c8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.remove_dir_all-0.5.3.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "remove_dir_all",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.5.3",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-hash-1.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-hash-1.1.0.bazel
new file mode 100644
index 0000000..def8f77
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-hash-1.1.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "rustc_hash",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-serialize-0.3.24.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-serialize-0.3.24.bazel
new file mode 100644
index 0000000..1f90255
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.rustc-serialize-0.3.24.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "rustc_serialize",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.24",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ryu-1.0.9.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ryu-1.0.9.bazel
new file mode 100644
index 0000000..c2a9c81
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ryu-1.0.9.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR BSL-1.0
+# ])
+
+rust_library(
+    name = "ryu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.same-file-1.0.6.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.same-file-1.0.6.bazel
new file mode 100644
index 0000000..0b5a6fd
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.same-file-1.0.6.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "same_file",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.6",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-util-0.1.5//:winapi_util",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.semver-1.0.6.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.semver-1.0.6.bazel
new file mode 100644
index 0000000..eb424d7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.semver-1.0.6.bazel
@@ -0,0 +1,178 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "semver",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "serde",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__semver-1.0.6//:build_script_build",
+            "@crate_index__serde-1.0.136//:serde",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "semver_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "serde",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.6",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "semver_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde-1.0.136.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde-1.0.136.bazel
new file mode 100644
index 0000000..9000cb6
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde-1.0.136.bazel
@@ -0,0 +1,182 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "derive",
+        "rc",
+        "serde_derive",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde_derive-1.0.136//:serde_derive",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.136",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "derive",
+        "rc",
+        "serde_derive",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.136",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_derive-1.0.136.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_derive-1.0.136.bazel
new file mode 100644
index 0000000..86a3203
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_derive-1.0.136.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "serde_derive",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.136",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+            "@crate_index__serde_derive-1.0.136//:build_script_build",
+            "@crate_index__syn-1.0.86//:syn",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_derive_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.136",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_derive_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_json-1.0.79.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_json-1.0.79.bazel
new file mode 100644
index 0000000..28b6043
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.serde_json-1.0.79.bazel
@@ -0,0 +1,180 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde_json",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+        "unbounded_depth",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.79",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__itoa-1.0.1//:itoa",
+            "@crate_index__ryu-1.0.9//:ryu",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__serde_json-1.0.79//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_json_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+        "unbounded_depth",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.79",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_json_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha-1-0.8.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha-1-0.8.2.bazel
new file mode 100644
index 0000000..788e2f3
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha-1-0.8.2.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "sha1",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__block-buffer-0.7.3//:block_buffer",
+            "@crate_index__digest-0.8.1//:digest",
+            "@crate_index__fake-simd-0.1.2//:fake_simd",
+            "@crate_index__opaque-debug-0.2.3//:opaque_debug",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha2-0.10.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha2-0.10.2.bazel
new file mode 100644
index 0000000..3d9fec2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.sha2-0.10.2.bazel
@@ -0,0 +1,113 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "sha2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.2",
+    deps = [
+    ] + select_with_or({
+        # cfg(any(target_arch = "aarch64", target_arch = "x86_64", target_arch = "x86"))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__cpufeatures-0.2.1//:cpufeatures",
+
+            # Common Deps
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__digest-0.10.3//:digest",
+        ],
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__digest-0.10.3//:digest",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.siphasher-0.3.9.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.siphasher-0.3.9.bazel
new file mode 100644
index 0000000..01801aa
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.siphasher-0.3.9.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "siphasher",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.slug-0.1.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.slug-0.1.4.bazel
new file mode 100644
index 0000000..0348887
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.slug-0.1.4.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "slug",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__deunicode-0.4.3//:deunicode",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smallvec-1.8.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smallvec-1.8.0.bazel
new file mode 100644
index 0000000..a9ae389
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smallvec-1.8.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smartstring-1.0.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smartstring-1.0.0.bazel
new file mode 100644
index 0000000..4331be2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smartstring-1.0.0.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MPL-2.0+
+# ])
+
+rust_library(
+    name = "smartstring",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "serde",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2021",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__static_assertions-1.1.0//:static_assertions",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smawk-0.3.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smawk-0.3.1.bazel
new file mode 100644
index 0000000..ba4de44
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.smawk-0.3.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "smawk",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.spectral-0.6.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.spectral-0.6.0.bazel
new file mode 100644
index 0000000..61ad65b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.spectral-0.6.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0
+# ])
+
+rust_library(
+    name = "spectral",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "num",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__num-0.1.42//:num",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.static_assertions-1.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.static_assertions-1.1.0.bazel
new file mode 100644
index 0000000..4e9f035
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.static_assertions-1.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "static_assertions",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.strsim-0.10.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.strsim-0.10.0.bazel
new file mode 100644
index 0000000..d44fe18
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.strsim-0.10.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "strsim",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.syn-1.0.86.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.syn-1.0.86.bazel
new file mode 100644
index 0000000..fba5009
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.syn-1.0.86.bazel
@@ -0,0 +1,190 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "syn",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.86",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__proc-macro2-1.0.36//:proc_macro2",
+            "@crate_index__quote-1.0.15//:quote",
+            "@crate_index__syn-1.0.86//:build_script_build",
+            "@crate_index__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "syn_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.86",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "syn_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tempfile-3.3.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tempfile-3.3.0.bazel
new file mode 100644
index 0000000..67ea9ad
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tempfile-3.3.0.bazel
@@ -0,0 +1,134 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "tempfile",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "3.3.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(any(unix, target_os = "wasi"))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crate_index__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__fastrand-1.7.0//:fastrand",
+            "@crate_index__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__fastrand-1.7.0//:fastrand",
+            "@crate_index__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+        "//conditions:default": [
+            "@crate_index__cfg-if-1.0.0//:cfg_if",
+            "@crate_index__fastrand-1.7.0//:fastrand",
+            "@crate_index__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tera-1.15.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tera-1.15.0.bazel
new file mode 100644
index 0000000..644e4bd
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tera-1.15.0.bazel
@@ -0,0 +1,106 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tera",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "builtins",
+        "chrono",
+        "chrono-tz",
+        "default",
+        "humansize",
+        "percent-encoding",
+        "rand",
+        "slug",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__pest_derive-2.1.0//:pest_derive",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.15.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__chrono-0.4.19//:chrono",
+            "@crate_index__chrono-tz-0.6.1//:chrono_tz",
+            "@crate_index__globwalk-0.8.1//:globwalk",
+            "@crate_index__humansize-1.1.1//:humansize",
+            "@crate_index__lazy_static-1.4.0//:lazy_static",
+            "@crate_index__percent-encoding-2.1.0//:percent_encoding",
+            "@crate_index__pest-2.1.3//:pest",
+            "@crate_index__rand-0.8.5//:rand",
+            "@crate_index__regex-1.5.4//:regex",
+            "@crate_index__serde-1.0.136//:serde",
+            "@crate_index__serde_json-1.0.79//:serde_json",
+            "@crate_index__slug-0.1.4//:slug",
+            "@crate_index__unic-segment-0.9.0//:unic_segment",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.termcolor-1.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.termcolor-1.1.3.bazel
new file mode 100644
index 0000000..49d7bb0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.termcolor-1.1.3.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense OR MIT
+# ])
+
+rust_library(
+    name = "termcolor",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.3",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-util-0.1.5//:winapi_util",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.14.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.14.2.bazel
new file mode 100644
index 0000000..ec7ccef
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.14.2.bazel
@@ -0,0 +1,91 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "textwrap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "smawk",
+        "unicode-linebreak",
+        "unicode-width",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__smawk-0.3.1//:smawk",
+            "@crate_index__unicode-linebreak-0.1.2//:unicode_linebreak",
+            "@crate_index__unicode-width-0.1.9//:unicode_width",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.15.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.15.0.bazel
new file mode 100644
index 0000000..6636e2c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.textwrap-0.15.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "textwrap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.15.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.thread_local-1.1.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.thread_local-1.1.4.bazel
new file mode 100644
index 0000000..ead5237
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.thread_local-1.1.4.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "thread_local",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__once_cell-1.9.0//:once_cell",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec-1.5.1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec-1.5.1.bazel
new file mode 100644
index 0000000..b366234
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec-1.5.1.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Zlib OR Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "tinyvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "tinyvec_macros",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.5.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__tinyvec_macros-0.1.0//:tinyvec_macros",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec_macros-0.1.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec_macros-0.1.0.bazel
new file mode 100644
index 0000000..f29536b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.tinyvec_macros-0.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0 OR Zlib
+# ])
+
+rust_library(
+    name = "tinyvec_macros",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.toml-0.5.8.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.toml-0.5.8.bazel
new file mode 100644
index 0000000..3aeedb8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.toml-0.5.8.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "toml",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.5.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__serde-1.0.136//:serde",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.typenum-1.15.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.typenum-1.15.0.bazel
new file mode 100644
index 0000000..bc9505b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.typenum-1.15.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "typenum",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.15.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__typenum-1.15.0//:build_script_main",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "typenum_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_main",
+    crate_root = "build/main.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.15.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_main",
+    actual = "typenum_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ucd-trie-0.1.3.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ucd-trie-0.1.3.bazel
new file mode 100644
index 0000000..1fee76a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.ucd-trie-0.1.3.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "ucd_trie",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.uncased-0.9.6.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.uncased-0.9.6.bazel
new file mode 100644
index 0000000..034645e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.uncased-0.9.6.bazel
@@ -0,0 +1,172 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "uncased",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__uncased-0.9.6//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "uncased_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.9.6",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__version_check-0.9.4//:version_check",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "uncased_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-property-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-property-0.9.0.bazel
new file mode 100644
index 0000000..4a1ed99
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-property-0.9.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_char_property",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__unic-char-range-0.9.0//:unic_char_range",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-range-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-range-0.9.0.bazel
new file mode 100644
index 0000000..446a684
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-char-range-0.9.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_char_range",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-common-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-common-0.9.0.bazel
new file mode 100644
index 0000000..4827fb0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-common-0.9.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_common",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-segment-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-segment-0.9.0.bazel
new file mode 100644
index 0000000..c57a794
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-segment-0.9.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_segment",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__unic-ucd-segment-0.9.0//:unic_ucd_segment",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-segment-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-segment-0.9.0.bazel
new file mode 100644
index 0000000..dbd70c5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-segment-0.9.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_ucd_segment",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__unic-char-property-0.9.0//:unic_char_property",
+            "@crate_index__unic-char-range-0.9.0//:unic_char_range",
+            "@crate_index__unic-ucd-version-0.9.0//:unic_ucd_version",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-version-0.9.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-version-0.9.0.bazel
new file mode 100644
index 0000000..12233f8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unic-ucd-version-0.9.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unic_ucd_version",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__unic-common-0.9.0//:unic_common",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-bidi-0.3.7.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-bidi-0.3.7.bazel
new file mode 100644
index 0000000..b412f9a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-bidi-0.3.7.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT / Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_bidi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-linebreak-0.1.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-linebreak-0.1.2.bazel
new file mode 100644
index 0000000..fea1adb
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-linebreak-0.1.2.bazel
@@ -0,0 +1,172 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_linebreak",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__unicode-linebreak-0.1.2//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "unicode-linebreak_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.2",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__regex-1.5.4//:regex",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "unicode-linebreak_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-normalization-0.1.19.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-normalization-0.1.19.bazel
new file mode 100644
index 0000000..805ffa9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-normalization-0.1.19.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_normalization",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__tinyvec-1.5.1//:tinyvec",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-width-0.1.9.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-width-0.1.9.bazel
new file mode 100644
index 0000000..6b610b7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-width-0.1.9.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_width",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..30562c1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.url-2.2.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.url-2.2.2.bazel
new file mode 100644
index 0000000..e2b0903
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.url-2.2.2.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "url",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__form_urlencoded-1.0.1//:form_urlencoded",
+            "@crate_index__idna-0.2.3//:idna",
+            "@crate_index__matches-0.1.9//:matches",
+            "@crate_index__percent-encoding-2.1.0//:percent_encoding",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.vcpkg-0.2.15.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.vcpkg-0.2.15.bazel
new file mode 100644
index 0000000..45dc115
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.vcpkg-0.2.15.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "vcpkg",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.version_check-0.9.4.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.version_check-0.9.4.bazel
new file mode 100644
index 0000000..2c446b0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.version_check-0.9.4.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "version_check",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.walkdir-2.3.2.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.walkdir-2.3.2.bazel
new file mode 100644
index 0000000..323795e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.walkdir-2.3.2.bazel
@@ -0,0 +1,97 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "walkdir",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.3.2",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+            "@crate_index__winapi-util-0.1.5//:winapi_util",
+
+            # Common Deps
+            "@crate_index__same-file-1.0.6//:same_file",
+        ],
+        "//conditions:default": [
+            "@crate_index__same-file-1.0.6//:same_file",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
new file mode 100644
index 0000000..aedee28
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "wasi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.10.2+wasi-snapshot-preview1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..32b584b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,213 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "handleapi",
+        "minwinbase",
+        "minwindef",
+        "ntsecapi",
+        "processenv",
+        "profileapi",
+        "shlobj",
+        "std",
+        "timezoneapi",
+        "winbase",
+        "wincon",
+        "winerror",
+        "winnt",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-i686-pc-windows-gnu 0.4.0","target":"winapi_i686_pc_windows_gnu"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-x86_64-pc-windows-gnu 0.4.0","target":"winapi_x86_64_pc_windows_gnu"}]
+        #
+        "//conditions:default": [
+            "@crate_index__winapi-0.3.9//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "handleapi",
+        "minwinbase",
+        "minwindef",
+        "ntsecapi",
+        "processenv",
+        "profileapi",
+        "shlobj",
+        "std",
+        "timezoneapi",
+        "winbase",
+        "wincon",
+        "winerror",
+        "winnt",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..0935a2c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__winapi-i686-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-i686-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-i686-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-util-0.1.5.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-util-0.1.5.bazel
new file mode 100644
index 0000000..44dd9b5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-util-0.1.5.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "winapi_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crate_index__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..13b50ee
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crate_index__winapi-x86_64-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-x86_64-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-x86_64-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/crates.bzl b/third_party/rules_rust/crate_universe/3rdparty/crates/crates.bzl
new file mode 100644
index 0000000..d02aa63
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/crates.bzl
@@ -0,0 +1,25 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""Rules for defining repositories for remote `crates_vendor` repositories"""
+
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/3rdparty/crates:defs.bzl", _crate_repositories = "crate_repositories")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:crates_vendor.bzl", "crates_vendor_remote_repository")
+
+def crate_repositories():
+    maybe(
+        crates_vendor_remote_repository,
+        name = "crate_index",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.bazel"),
+        defs_module = Label("@rules_rust//crate_universe/3rdparty/crates:defs.bzl"),
+    )
+
+    _crate_repositories()
diff --git a/third_party/rules_rust/crate_universe/3rdparty/crates/defs.bzl b/third_party/rules_rust/crate_universe/3rdparty/crates/defs.bzl
new file mode 100644
index 0000000..4026391
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/crates/defs.bzl
@@ -0,0 +1,1979 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = None):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {
+    "crate_universe": {
+        _COMMON_CONDITION: {
+            "anyhow": "@crate_index__anyhow-1.0.55//:anyhow",
+            "cargo-lock": "@crate_index__cargo-lock-7.0.1//:cargo_lock",
+            "cargo-platform": "@crate_index__cargo-platform-0.1.2//:cargo_platform",
+            "cargo_metadata": "@crate_index__cargo_metadata-0.14.2//:cargo_metadata",
+            "cargo_toml": "@crate_index__cargo_toml-0.11.4//:cargo_toml",
+            "cfg-expr": "@crate_index__cfg-expr-0.10.2//:cfg_expr",
+            "clap": "@crate_index__clap-3.1.5//:clap",
+            "crates-index": "@crate_index__crates-index-0.18.7//:crates_index",
+            "hex": "@crate_index__hex-0.4.3//:hex",
+            "pathdiff": "@crate_index__pathdiff-0.2.1//:pathdiff",
+            "regex": "@crate_index__regex-1.5.4//:regex",
+            "semver": "@crate_index__semver-1.0.6//:semver",
+            "serde": "@crate_index__serde-1.0.136//:serde",
+            "serde_json": "@crate_index__serde_json-1.0.79//:serde_json",
+            "sha2": "@crate_index__sha2-0.10.2//:sha2",
+            "tempfile": "@crate_index__tempfile-3.3.0//:tempfile",
+            "tera": "@crate_index__tera-1.15.0//:tera",
+            "textwrap": "@crate_index__textwrap-0.14.2//:textwrap",
+            "toml": "@crate_index__toml-0.5.8//:toml",
+        },
+    },
+    "crate_universe/tools/cross_installer": {
+        _COMMON_CONDITION: {
+            "clap": "@crate_index__clap-3.1.5//:clap",
+        },
+    },
+    "crate_universe/tools/urls_generator": {
+        _COMMON_CONDITION: {
+            "clap": "@crate_index__clap-3.1.5//:clap",
+            "hex": "@crate_index__hex-0.4.3//:hex",
+            "serde_json": "@crate_index__serde_json-1.0.79//:serde_json",
+            "sha2": "@crate_index__sha2-0.10.2//:sha2",
+        },
+    },
+}
+
+_NORMAL_ALIASES = {
+    "crate_universe": {
+        _COMMON_CONDITION: {
+        },
+    },
+    "crate_universe/tools/cross_installer": {
+        _COMMON_CONDITION: {
+        },
+    },
+    "crate_universe/tools/urls_generator": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_NORMAL_DEV_DEPENDENCIES = {
+    "crate_universe": {
+        _COMMON_CONDITION: {
+            "spectral": "@crate_index__spectral-0.6.0//:spectral",
+        },
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_NORMAL_DEV_ALIASES = {
+    "crate_universe": {
+        _COMMON_CONDITION: {
+        },
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_PROC_MACRO_DEPENDENCIES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_PROC_MACRO_ALIASES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_PROC_MACRO_DEV_ALIASES = {
+    "crate_universe": {
+        _COMMON_CONDITION: {
+        },
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_BUILD_DEPENDENCIES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_BUILD_ALIASES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_BUILD_PROC_MACRO_ALIASES = {
+    "crate_universe": {
+    },
+    "crate_universe/tools/cross_installer": {
+    },
+    "crate_universe/tools/urls_generator": {
+    },
+}
+
+_CONDITIONS = {
+    "aarch64-apple-darwin": ["aarch64-apple-darwin"],
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))": ["aarch64-unknown-linux-gnu"],
+    "cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "i686-apple-darwin", "i686-linux-android", "i686-pc-windows-msvc", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-pc-windows-msvc", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(any(unix, target_os = \"wasi\"))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(not(windows))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(target_arch = \"wasm32\")": ["wasm32-unknown-unknown", "wasm32-wasi"],
+    "cfg(target_env = \"sgx\")": [],
+    "cfg(target_os = \"fuchsia\")": [],
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"wasi\")": ["wasm32-wasi"],
+    "cfg(unix)": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(windows)": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": [],
+}
+
+###############################################################################
+
+def crate_repositories():
+    """A macro for defining repositories for all generated crates"""
+    maybe(
+        http_archive,
+        name = "crate_index__aho-corasick-0.7.18",
+        sha256 = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/aho-corasick/0.7.18/download"],
+        strip_prefix = "aho-corasick-0.7.18",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.aho-corasick-0.7.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__anyhow-1.0.55",
+        sha256 = "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/anyhow/1.0.55/download"],
+        strip_prefix = "anyhow-1.0.55",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.anyhow-1.0.55.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__atty-0.2.14",
+        sha256 = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/atty/0.2.14/download"],
+        strip_prefix = "atty-0.2.14",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.atty-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__autocfg-1.1.0",
+        sha256 = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/autocfg/1.1.0/download"],
+        strip_prefix = "autocfg-1.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.autocfg-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__bitflags-1.3.2",
+        sha256 = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bitflags/1.3.2/download"],
+        strip_prefix = "bitflags-1.3.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.bitflags-1.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__block-buffer-0.10.2",
+        sha256 = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/block-buffer/0.10.2/download"],
+        strip_prefix = "block-buffer-0.10.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.block-buffer-0.10.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__block-buffer-0.7.3",
+        sha256 = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/block-buffer/0.7.3/download"],
+        strip_prefix = "block-buffer-0.7.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.block-buffer-0.7.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__block-padding-0.1.5",
+        sha256 = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/block-padding/0.1.5/download"],
+        strip_prefix = "block-padding-0.1.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.block-padding-0.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__bstr-0.2.17",
+        sha256 = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bstr/0.2.17/download"],
+        strip_prefix = "bstr-0.2.17",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.bstr-0.2.17.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__byte-tools-0.3.1",
+        sha256 = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/byte-tools/0.3.1/download"],
+        strip_prefix = "byte-tools-0.3.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.byte-tools-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__byteorder-1.4.3",
+        sha256 = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/byteorder/1.4.3/download"],
+        strip_prefix = "byteorder-1.4.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.byteorder-1.4.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__camino-1.0.7",
+        sha256 = "6f3132262930b0522068049f5870a856ab8affc80c70d08b6ecb785771a6fc23",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/camino/1.0.7/download"],
+        strip_prefix = "camino-1.0.7",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.camino-1.0.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cargo-lock-7.0.1",
+        sha256 = "7fb04b88bd5b2036e30704f95c6ee16f3b5ca3b4ca307da2889d9006648e5c88",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cargo-lock/7.0.1/download"],
+        strip_prefix = "cargo-lock-7.0.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cargo-lock-7.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cargo-platform-0.1.2",
+        sha256 = "cbdb825da8a5df079a43676dbe042702f1707b1109f713a01420fbb4cc71fa27",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cargo-platform/0.1.2/download"],
+        strip_prefix = "cargo-platform-0.1.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cargo-platform-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cargo_metadata-0.14.2",
+        sha256 = "4acbb09d9ee8e23699b9634375c72795d095bf268439da88562cf9b501f181fa",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cargo_metadata/0.14.2/download"],
+        strip_prefix = "cargo_metadata-0.14.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cargo_metadata-0.14.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cargo_toml-0.11.4",
+        sha256 = "4e270ef0cd868745878982f7ce470aa898d0d4bb248af67f0cf66f54617913ef",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cargo_toml/0.11.4/download"],
+        strip_prefix = "cargo_toml-0.11.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cargo_toml-0.11.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cc-1.0.73",
+        sha256 = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cc/1.0.73/download"],
+        strip_prefix = "cc-1.0.73",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cc-1.0.73.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cfg-expr-0.10.2",
+        sha256 = "5e068cb2806bbc15b439846dc16c5f89f8599f2c3e4d73d4449d38f9b2f0b6c5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cfg-expr/0.10.2/download"],
+        strip_prefix = "cfg-expr-0.10.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cfg-expr-0.10.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cfg-if-1.0.0",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cfg-if/1.0.0/download"],
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__chrono-0.4.19",
+        sha256 = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/chrono/0.4.19/download"],
+        strip_prefix = "chrono-0.4.19",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.chrono-0.4.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__chrono-tz-0.6.1",
+        sha256 = "58549f1842da3080ce63002102d5bc954c7bc843d4f47818e642abdc36253552",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/chrono-tz/0.6.1/download"],
+        strip_prefix = "chrono-tz-0.6.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.chrono-tz-0.6.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__chrono-tz-build-0.0.2",
+        sha256 = "db058d493fb2f65f41861bfed7e3fe6335264a9f0f92710cab5bdf01fef09069",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/chrono-tz-build/0.0.2/download"],
+        strip_prefix = "chrono-tz-build-0.0.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.chrono-tz-build-0.0.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__clap-3.1.5",
+        sha256 = "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/clap/3.1.5/download"],
+        strip_prefix = "clap-3.1.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.clap-3.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__clap_derive-3.1.4",
+        sha256 = "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/clap_derive/3.1.4/download"],
+        strip_prefix = "clap_derive-3.1.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.clap_derive-3.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__cpufeatures-0.2.1",
+        sha256 = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cpufeatures/0.2.1/download"],
+        strip_prefix = "cpufeatures-0.2.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.cpufeatures-0.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__crates-index-0.18.7",
+        sha256 = "0044896374c388ccbf1497dad6384bf6111dbcad9d7069506df7450ce9b62ea3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/crates-index/0.18.7/download"],
+        strip_prefix = "crates-index-0.18.7",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.crates-index-0.18.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__crossbeam-utils-0.8.7",
+        sha256 = "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/crossbeam-utils/0.8.7/download"],
+        strip_prefix = "crossbeam-utils-0.8.7",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.crossbeam-utils-0.8.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__crypto-common-0.1.3",
+        sha256 = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/crypto-common/0.1.3/download"],
+        strip_prefix = "crypto-common-0.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.crypto-common-0.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__deunicode-0.4.3",
+        sha256 = "850878694b7933ca4c9569d30a34b55031b9b139ee1fc7b94a527c4ef960d690",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/deunicode/0.4.3/download"],
+        strip_prefix = "deunicode-0.4.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.deunicode-0.4.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__digest-0.10.3",
+        sha256 = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/digest/0.10.3/download"],
+        strip_prefix = "digest-0.10.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.digest-0.10.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__digest-0.8.1",
+        sha256 = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/digest/0.8.1/download"],
+        strip_prefix = "digest-0.8.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.digest-0.8.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__fake-simd-0.1.2",
+        sha256 = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fake-simd/0.1.2/download"],
+        strip_prefix = "fake-simd-0.1.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.fake-simd-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__fastrand-1.7.0",
+        sha256 = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fastrand/1.7.0/download"],
+        strip_prefix = "fastrand-1.7.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.fastrand-1.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__fnv-1.0.7",
+        sha256 = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fnv/1.0.7/download"],
+        strip_prefix = "fnv-1.0.7",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.fnv-1.0.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__form_urlencoded-1.0.1",
+        sha256 = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download"],
+        strip_prefix = "form_urlencoded-1.0.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.form_urlencoded-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__fuchsia-cprng-0.1.1",
+        sha256 = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fuchsia-cprng/0.1.1/download"],
+        strip_prefix = "fuchsia-cprng-0.1.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.fuchsia-cprng-0.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__generic-array-0.12.4",
+        sha256 = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/generic-array/0.12.4/download"],
+        strip_prefix = "generic-array-0.12.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.generic-array-0.12.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__generic-array-0.14.5",
+        sha256 = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/generic-array/0.14.5/download"],
+        strip_prefix = "generic-array-0.14.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.generic-array-0.14.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__getrandom-0.2.5",
+        sha256 = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/getrandom/0.2.5/download"],
+        strip_prefix = "getrandom-0.2.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.getrandom-0.2.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__git2-0.14.1",
+        sha256 = "6e7d3b96ec1fcaa8431cf04a4f1ef5caafe58d5cf7bcc31f09c1626adddb0ffe",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/git2/0.14.1/download"],
+        strip_prefix = "git2-0.14.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.git2-0.14.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__globset-0.4.8",
+        sha256 = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/globset/0.4.8/download"],
+        strip_prefix = "globset-0.4.8",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.globset-0.4.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__globwalk-0.8.1",
+        sha256 = "93e3af942408868f6934a7b85134a3230832b9977cf66125df2f9edcfce4ddcc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/globwalk/0.8.1/download"],
+        strip_prefix = "globwalk-0.8.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.globwalk-0.8.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__hashbrown-0.11.2",
+        sha256 = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hashbrown/0.11.2/download"],
+        strip_prefix = "hashbrown-0.11.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.hashbrown-0.11.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__heck-0.4.0",
+        sha256 = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/heck/0.4.0/download"],
+        strip_prefix = "heck-0.4.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.heck-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__hermit-abi-0.1.19",
+        sha256 = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hermit-abi/0.1.19/download"],
+        strip_prefix = "hermit-abi-0.1.19",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.hermit-abi-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__hex-0.4.3",
+        sha256 = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hex/0.4.3/download"],
+        strip_prefix = "hex-0.4.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.hex-0.4.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__home-0.5.3",
+        sha256 = "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/home/0.5.3/download"],
+        strip_prefix = "home-0.5.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.home-0.5.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__humansize-1.1.1",
+        sha256 = "02296996cb8796d7c6e3bc2d9211b7802812d36999a51bb754123ead7d37d026",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/humansize/1.1.1/download"],
+        strip_prefix = "humansize-1.1.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.humansize-1.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__idna-0.2.3",
+        sha256 = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/idna/0.2.3/download"],
+        strip_prefix = "idna-0.2.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.idna-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__ignore-0.4.18",
+        sha256 = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ignore/0.4.18/download"],
+        strip_prefix = "ignore-0.4.18",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.ignore-0.4.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__indexmap-1.8.0",
+        sha256 = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/indexmap/1.8.0/download"],
+        strip_prefix = "indexmap-1.8.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.indexmap-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__instant-0.1.12",
+        sha256 = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/instant/0.1.12/download"],
+        strip_prefix = "instant-0.1.12",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.instant-0.1.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__itoa-1.0.1",
+        sha256 = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/itoa/1.0.1/download"],
+        strip_prefix = "itoa-1.0.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.itoa-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__jobserver-0.1.24",
+        sha256 = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/jobserver/0.1.24/download"],
+        strip_prefix = "jobserver-0.1.24",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.jobserver-0.1.24.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__lazy_static-1.4.0",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/lazy_static/1.4.0/download"],
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__libc-0.2.119",
+        sha256 = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/libc/0.2.119/download"],
+        strip_prefix = "libc-0.2.119",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.libc-0.2.119.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__libgit2-sys-0.13.1-1.4.2",
+        sha256 = "43e598aa7a4faedf1ea1b4608f582b06f0f40211eec551b7ef36019ae3f62def",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/libgit2-sys/0.13.1+1.4.2/download"],
+        strip_prefix = "libgit2-sys-0.13.1+1.4.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.libgit2-sys-0.13.1+1.4.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__libz-sys-1.1.3",
+        sha256 = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/libz-sys/1.1.3/download"],
+        strip_prefix = "libz-sys-1.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.libz-sys-1.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__log-0.4.14",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/log/0.4.14/download"],
+        strip_prefix = "log-0.4.14",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__maplit-1.0.2",
+        sha256 = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/maplit/1.0.2/download"],
+        strip_prefix = "maplit-1.0.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.maplit-1.0.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__matches-0.1.9",
+        sha256 = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/matches/0.1.9/download"],
+        strip_prefix = "matches-0.1.9",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.matches-0.1.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__memchr-2.4.1",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/memchr/2.4.1/download"],
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-0.1.42",
+        sha256 = "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num/0.1.42/download"],
+        strip_prefix = "num-0.1.42",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-0.1.42.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-bigint-0.1.44",
+        sha256 = "e63899ad0da84ce718c14936262a41cee2c79c981fc0a0e7c7beb47d5a07e8c1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-bigint/0.1.44/download"],
+        strip_prefix = "num-bigint-0.1.44",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-bigint-0.1.44.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-complex-0.1.43",
+        sha256 = "b288631d7878aaf59442cffd36910ea604ecd7745c36054328595114001c9656",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-complex/0.1.43/download"],
+        strip_prefix = "num-complex-0.1.43",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-complex-0.1.43.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-integer-0.1.44",
+        sha256 = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-integer/0.1.44/download"],
+        strip_prefix = "num-integer-0.1.44",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-integer-0.1.44.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-iter-0.1.42",
+        sha256 = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-iter/0.1.42/download"],
+        strip_prefix = "num-iter-0.1.42",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-iter-0.1.42.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-rational-0.1.42",
+        sha256 = "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-rational/0.1.42/download"],
+        strip_prefix = "num-rational-0.1.42",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-rational-0.1.42.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num-traits-0.2.14",
+        sha256 = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num-traits/0.2.14/download"],
+        strip_prefix = "num-traits-0.2.14",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num-traits-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__num_cpus-1.13.1",
+        sha256 = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num_cpus/1.13.1/download"],
+        strip_prefix = "num_cpus-1.13.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.num_cpus-1.13.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__once_cell-1.9.0",
+        sha256 = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/once_cell/1.9.0/download"],
+        strip_prefix = "once_cell-1.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.once_cell-1.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__opaque-debug-0.2.3",
+        sha256 = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/opaque-debug/0.2.3/download"],
+        strip_prefix = "opaque-debug-0.2.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.opaque-debug-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__os_str_bytes-6.0.0",
+        sha256 = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/os_str_bytes/6.0.0/download"],
+        strip_prefix = "os_str_bytes-6.0.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.os_str_bytes-6.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__parse-zoneinfo-0.3.0",
+        sha256 = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/parse-zoneinfo/0.3.0/download"],
+        strip_prefix = "parse-zoneinfo-0.3.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.parse-zoneinfo-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pathdiff-0.2.1",
+        sha256 = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pathdiff/0.2.1/download"],
+        strip_prefix = "pathdiff-0.2.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pathdiff-0.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__percent-encoding-2.1.0",
+        sha256 = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/percent-encoding/2.1.0/download"],
+        strip_prefix = "percent-encoding-2.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.percent-encoding-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pest-2.1.3",
+        sha256 = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pest/2.1.3/download"],
+        strip_prefix = "pest-2.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pest-2.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pest_derive-2.1.0",
+        sha256 = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pest_derive/2.1.0/download"],
+        strip_prefix = "pest_derive-2.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pest_derive-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pest_generator-2.1.3",
+        sha256 = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pest_generator/2.1.3/download"],
+        strip_prefix = "pest_generator-2.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pest_generator-2.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pest_meta-2.1.3",
+        sha256 = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pest_meta/2.1.3/download"],
+        strip_prefix = "pest_meta-2.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pest_meta-2.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__phf-0.10.1",
+        sha256 = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/phf/0.10.1/download"],
+        strip_prefix = "phf-0.10.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.phf-0.10.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__phf_codegen-0.10.0",
+        sha256 = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/phf_codegen/0.10.0/download"],
+        strip_prefix = "phf_codegen-0.10.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.phf_codegen-0.10.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__phf_generator-0.10.0",
+        sha256 = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/phf_generator/0.10.0/download"],
+        strip_prefix = "phf_generator-0.10.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.phf_generator-0.10.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__phf_shared-0.10.0",
+        sha256 = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/phf_shared/0.10.0/download"],
+        strip_prefix = "phf_shared-0.10.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.phf_shared-0.10.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__pkg-config-0.3.24",
+        sha256 = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pkg-config/0.3.24/download"],
+        strip_prefix = "pkg-config-0.3.24",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.pkg-config-0.3.24.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__ppv-lite86-0.2.16",
+        sha256 = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ppv-lite86/0.2.16/download"],
+        strip_prefix = "ppv-lite86-0.2.16",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.ppv-lite86-0.2.16.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__proc-macro-error-1.0.4",
+        sha256 = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/proc-macro-error/1.0.4/download"],
+        strip_prefix = "proc-macro-error-1.0.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.proc-macro-error-1.0.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__proc-macro-error-attr-1.0.4",
+        sha256 = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/proc-macro-error-attr/1.0.4/download"],
+        strip_prefix = "proc-macro-error-attr-1.0.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.proc-macro-error-attr-1.0.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__proc-macro2-1.0.36",
+        sha256 = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/proc-macro2/1.0.36/download"],
+        strip_prefix = "proc-macro2-1.0.36",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.proc-macro2-1.0.36.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__quote-1.0.15",
+        sha256 = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/quote/1.0.15/download"],
+        strip_prefix = "quote-1.0.15",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.quote-1.0.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand-0.4.6",
+        sha256 = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand/0.4.6/download"],
+        strip_prefix = "rand-0.4.6",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand-0.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand-0.8.5",
+        sha256 = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand/0.8.5/download"],
+        strip_prefix = "rand-0.8.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand-0.8.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand_chacha-0.3.1",
+        sha256 = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand_chacha/0.3.1/download"],
+        strip_prefix = "rand_chacha-0.3.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand_chacha-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand_core-0.3.1",
+        sha256 = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand_core/0.3.1/download"],
+        strip_prefix = "rand_core-0.3.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand_core-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand_core-0.4.2",
+        sha256 = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand_core/0.4.2/download"],
+        strip_prefix = "rand_core-0.4.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand_core-0.4.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rand_core-0.6.3",
+        sha256 = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rand_core/0.6.3/download"],
+        strip_prefix = "rand_core-0.6.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rand_core-0.6.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rdrand-0.4.0",
+        sha256 = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rdrand/0.4.0/download"],
+        strip_prefix = "rdrand-0.4.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rdrand-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__redox_syscall-0.2.11",
+        sha256 = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/redox_syscall/0.2.11/download"],
+        strip_prefix = "redox_syscall-0.2.11",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.redox_syscall-0.2.11.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__regex-1.5.4",
+        sha256 = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/regex/1.5.4/download"],
+        strip_prefix = "regex-1.5.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.regex-1.5.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__regex-syntax-0.6.25",
+        sha256 = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/regex-syntax/0.6.25/download"],
+        strip_prefix = "regex-syntax-0.6.25",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.regex-syntax-0.6.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__remove_dir_all-0.5.3",
+        sha256 = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/remove_dir_all/0.5.3/download"],
+        strip_prefix = "remove_dir_all-0.5.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.remove_dir_all-0.5.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rustc-hash-1.1.0",
+        sha256 = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rustc-hash/1.1.0/download"],
+        strip_prefix = "rustc-hash-1.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rustc-hash-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__rustc-serialize-0.3.24",
+        sha256 = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/rustc-serialize/0.3.24/download"],
+        strip_prefix = "rustc-serialize-0.3.24",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.rustc-serialize-0.3.24.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__ryu-1.0.9",
+        sha256 = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ryu/1.0.9/download"],
+        strip_prefix = "ryu-1.0.9",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.ryu-1.0.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__same-file-1.0.6",
+        sha256 = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/same-file/1.0.6/download"],
+        strip_prefix = "same-file-1.0.6",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.same-file-1.0.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__semver-1.0.6",
+        sha256 = "a4a3381e03edd24287172047536f20cabde766e2cd3e65e6b00fb3af51c4f38d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/semver/1.0.6/download"],
+        strip_prefix = "semver-1.0.6",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.semver-1.0.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__serde-1.0.136",
+        sha256 = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde/1.0.136/download"],
+        strip_prefix = "serde-1.0.136",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.serde-1.0.136.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__serde_derive-1.0.136",
+        sha256 = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde_derive/1.0.136/download"],
+        strip_prefix = "serde_derive-1.0.136",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.serde_derive-1.0.136.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__serde_json-1.0.79",
+        sha256 = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde_json/1.0.79/download"],
+        strip_prefix = "serde_json-1.0.79",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.serde_json-1.0.79.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__sha-1-0.8.2",
+        sha256 = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/sha-1/0.8.2/download"],
+        strip_prefix = "sha-1-0.8.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.sha-1-0.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__sha2-0.10.2",
+        sha256 = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/sha2/0.10.2/download"],
+        strip_prefix = "sha2-0.10.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.sha2-0.10.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__siphasher-0.3.9",
+        sha256 = "a86232ab60fa71287d7f2ddae4a7073f6b7aac33631c3015abb556f08c6d0a3e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/siphasher/0.3.9/download"],
+        strip_prefix = "siphasher-0.3.9",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.siphasher-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__slug-0.1.4",
+        sha256 = "b3bc762e6a4b6c6fcaade73e77f9ebc6991b676f88bb2358bddb56560f073373",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/slug/0.1.4/download"],
+        strip_prefix = "slug-0.1.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.slug-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__smallvec-1.8.0",
+        sha256 = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/smallvec/1.8.0/download"],
+        strip_prefix = "smallvec-1.8.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.smallvec-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__smartstring-1.0.0",
+        sha256 = "ea958ad90cacc8ece7f238fde3671e1b350ee1741964edf2a22fd16f60224163",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/smartstring/1.0.0/download"],
+        strip_prefix = "smartstring-1.0.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.smartstring-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__smawk-0.3.1",
+        sha256 = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/smawk/0.3.1/download"],
+        strip_prefix = "smawk-0.3.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.smawk-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__spectral-0.6.0",
+        sha256 = "ae3c15181f4b14e52eeaac3efaeec4d2764716ce9c86da0c934c3e318649c5ba",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/spectral/0.6.0/download"],
+        strip_prefix = "spectral-0.6.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.spectral-0.6.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__static_assertions-1.1.0",
+        sha256 = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/static_assertions/1.1.0/download"],
+        strip_prefix = "static_assertions-1.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.static_assertions-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__strsim-0.10.0",
+        sha256 = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/strsim/0.10.0/download"],
+        strip_prefix = "strsim-0.10.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.strsim-0.10.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__syn-1.0.86",
+        sha256 = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/syn/1.0.86/download"],
+        strip_prefix = "syn-1.0.86",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.syn-1.0.86.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__tempfile-3.3.0",
+        sha256 = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tempfile/3.3.0/download"],
+        strip_prefix = "tempfile-3.3.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.tempfile-3.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__tera-1.15.0",
+        sha256 = "d3cac831b615c25bcef632d1cabf864fa05813baad3d526829db18eb70e8b58d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tera/1.15.0/download"],
+        strip_prefix = "tera-1.15.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.tera-1.15.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__termcolor-1.1.3",
+        sha256 = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/termcolor/1.1.3/download"],
+        strip_prefix = "termcolor-1.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.termcolor-1.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__textwrap-0.14.2",
+        sha256 = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/textwrap/0.14.2/download"],
+        strip_prefix = "textwrap-0.14.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.textwrap-0.14.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__textwrap-0.15.0",
+        sha256 = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/textwrap/0.15.0/download"],
+        strip_prefix = "textwrap-0.15.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.textwrap-0.15.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__thread_local-1.1.4",
+        sha256 = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/thread_local/1.1.4/download"],
+        strip_prefix = "thread_local-1.1.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.thread_local-1.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__tinyvec-1.5.1",
+        sha256 = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tinyvec/1.5.1/download"],
+        strip_prefix = "tinyvec-1.5.1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.tinyvec-1.5.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__tinyvec_macros-0.1.0",
+        sha256 = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tinyvec_macros/0.1.0/download"],
+        strip_prefix = "tinyvec_macros-0.1.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.tinyvec_macros-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__toml-0.5.8",
+        sha256 = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/toml/0.5.8/download"],
+        strip_prefix = "toml-0.5.8",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.toml-0.5.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__typenum-1.15.0",
+        sha256 = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/typenum/1.15.0/download"],
+        strip_prefix = "typenum-1.15.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.typenum-1.15.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__ucd-trie-0.1.3",
+        sha256 = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ucd-trie/0.1.3/download"],
+        strip_prefix = "ucd-trie-0.1.3",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.ucd-trie-0.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__uncased-0.9.6",
+        sha256 = "5baeed7327e25054889b9bd4f975f32e5f4c5d434042d59ab6cd4142c0a76ed0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/uncased/0.9.6/download"],
+        strip_prefix = "uncased-0.9.6",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.uncased-0.9.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-char-property-0.9.0",
+        sha256 = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-char-property/0.9.0/download"],
+        strip_prefix = "unic-char-property-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-char-property-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-char-range-0.9.0",
+        sha256 = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-char-range/0.9.0/download"],
+        strip_prefix = "unic-char-range-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-char-range-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-common-0.9.0",
+        sha256 = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-common/0.9.0/download"],
+        strip_prefix = "unic-common-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-common-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-segment-0.9.0",
+        sha256 = "e4ed5d26be57f84f176157270c112ef57b86debac9cd21daaabbe56db0f88f23",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-segment/0.9.0/download"],
+        strip_prefix = "unic-segment-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-segment-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-ucd-segment-0.9.0",
+        sha256 = "2079c122a62205b421f499da10f3ee0f7697f012f55b675e002483c73ea34700",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-ucd-segment/0.9.0/download"],
+        strip_prefix = "unic-ucd-segment-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-ucd-segment-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unic-ucd-version-0.9.0",
+        sha256 = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unic-ucd-version/0.9.0/download"],
+        strip_prefix = "unic-ucd-version-0.9.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unic-ucd-version-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unicode-bidi-0.3.7",
+        sha256 = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-bidi/0.3.7/download"],
+        strip_prefix = "unicode-bidi-0.3.7",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unicode-bidi-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unicode-linebreak-0.1.2",
+        sha256 = "3a52dcaab0c48d931f7cc8ef826fa51690a08e1ea55117ef26f89864f532383f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-linebreak/0.1.2/download"],
+        strip_prefix = "unicode-linebreak-0.1.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unicode-linebreak-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unicode-normalization-0.1.19",
+        sha256 = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-normalization/0.1.19/download"],
+        strip_prefix = "unicode-normalization-0.1.19",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unicode-normalization-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unicode-width-0.1.9",
+        sha256 = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-width/0.1.9/download"],
+        strip_prefix = "unicode-width-0.1.9",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unicode-width-0.1.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__unicode-xid-0.2.2",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-xid/0.2.2/download"],
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__url-2.2.2",
+        sha256 = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/url/2.2.2/download"],
+        strip_prefix = "url-2.2.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.url-2.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__vcpkg-0.2.15",
+        sha256 = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/vcpkg/0.2.15/download"],
+        strip_prefix = "vcpkg-0.2.15",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.vcpkg-0.2.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__version_check-0.9.4",
+        sha256 = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/version_check/0.9.4/download"],
+        strip_prefix = "version_check-0.9.4",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.version_check-0.9.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__walkdir-2.3.2",
+        sha256 = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/walkdir/2.3.2/download"],
+        strip_prefix = "walkdir-2.3.2",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.walkdir-2.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__wasi-0.10.2-wasi-snapshot-preview1",
+        sha256 = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download"],
+        strip_prefix = "wasi-0.10.2+wasi-snapshot-preview1",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__winapi-0.3.9",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi/0.3.9/download"],
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__winapi-i686-pc-windows-gnu-0.4.0",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__winapi-util-0.1.5",
+        sha256 = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-util/0.1.5/download"],
+        strip_prefix = "winapi-util-0.1.5",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.winapi-util-0.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crate_index__winapi-x86_64-pc-windows-gnu-0.4.0",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("@rules_rust//crate_universe/3rdparty/crates:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
diff --git a/third_party/rules_rust/crate_universe/3rdparty/third_party_deps.bzl b/third_party/rules_rust/crate_universe/3rdparty/third_party_deps.bzl
new file mode 100644
index 0000000..54468e4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/3rdparty/third_party_deps.bzl
@@ -0,0 +1,28 @@
+"""Third party dependencies of `cargo-bazel`"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+def third_party_deps():
+    maybe(
+        http_archive,
+        name = "zlib",
+        build_file = Label("//crate_universe/3rdparty:BUILD.zlib.bazel"),
+        sha256 = "c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1",
+        strip_prefix = "zlib-1.2.11",
+        urls = [
+            "https://zlib.net/zlib-1.2.11.tar.gz",
+            "https://storage.googleapis.com/mirror.tensorflow.org/zlib.net/zlib-1.2.11.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = "libgit2",
+        build_file = Label("//crate_universe/3rdparty:BUILD.libgit2.bazel"),
+        sha256 = "9051e75964350054d5e3f9339bc4d1fb56ac14949710e3860f98f07a0433fa25",
+        # The version here should match the version used with the Rust crate `libgit2-sys`
+        # https://github.com/rust-lang/git2-rs/tree/libgit2-sys-0.13.0/libgit2-sys
+        strip_prefix = "libgit2-1.4.0",
+        urls = ["https://github.com/libgit2/libgit2/archive/refs/tags/v1.4.0.tar.gz"],
+    )
diff --git a/third_party/rules_rust/crate_universe/BUILD.bazel b/third_party/rules_rust/crate_universe/BUILD.bazel
new file mode 100644
index 0000000..6ef161c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/BUILD.bazel
@@ -0,0 +1,130 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@crate_index//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_doc", "rust_library", "rust_test")
+load("//crate_universe:version.bzl", "VERSION")
+
+exports_files(
+    glob(["src/**"]) + [
+        "Cargo.toml",
+        "Cargo.lock",
+        "Cargo.Bazel.lock",
+        "defs.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "distro",
+    srcs = glob(["*.bzl"]) + [
+        ":rust_srcs",
+        "//crate_universe/3rdparty:distro",
+        "//crate_universe/private:distro",
+        "//crate_universe/tools:distro",
+        "BUILD.bazel",
+        "Cargo.Bazel.lock",
+        "Cargo.lock",
+        "Cargo.toml",
+        "README.md",
+    ],
+    visibility = ["//:__subpackages__"],
+)
+
+filegroup(
+    name = "bzl_srcs",
+    srcs = glob(["*.bzl"]) + [
+        "//crate_universe/3rdparty:bzl_srcs",
+        "//crate_universe/private:bzl_srcs",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = [":bzl_srcs"],
+    visibility = ["//visibility:public"],
+    deps = ["//rust:bzl_lib"],
+)
+
+filegroup(
+    name = "rust_srcs",
+    srcs = glob([
+        "src/**/*.rs",
+        "src/**/*.j2",
+    ]),
+    visibility = ["//:__subpackages__"],
+)
+
+TAGS = [
+    # https://github.com/rust-lang/rust-clippy/issues/8470
+    "noclippy",
+]
+
+rust_library(
+    name = "cargo_bazel",
+    srcs = glob(
+        include = ["src/**/*.rs"],
+        exclude = ["src/main.rs"],
+    ),
+    aliases = aliases(),
+    compile_data = glob(
+        include = ["src/**"],
+        exclude = ["src/**/*.rs"],
+    ),
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    tags = TAGS,
+    version = VERSION,
+    visibility = ["//visibility:public"],
+    deps = all_crate_deps(normal = True),
+)
+
+rust_binary(
+    name = "cargo_bazel_bin",
+    srcs = ["src/main.rs"],
+    tags = TAGS,
+    version = VERSION,
+    visibility = ["//visibility:public"],
+    deps = [":cargo_bazel"],
+)
+
+alias(
+    name = "bin",
+    actual = ":cargo_bazel_bin",
+    visibility = ["//visibility:public"],
+)
+
+rust_test(
+    name = "unit_test",
+    aliases = aliases(),
+    crate = ":cargo_bazel",
+    data = glob(["test_data/**"]) + [
+        "@rules_rust//rust/toolchain:current_exec_cargo_files",
+        "@rules_rust//rust/toolchain:current_exec_rustc_files",
+    ],
+    proc_macro_deps = all_crate_deps(
+        proc_macro_dev = True,
+    ),
+    rustc_env = {
+        "CARGO": "$(rootpath @rules_rust//rust/toolchain:current_exec_cargo_files)",
+        "RUSTC": "$(rootpath @rules_rust//rust/toolchain:current_exec_rustc_files)",
+    },
+    tags = TAGS,
+    deps = [
+        "@rules_rust//tools/runfiles",
+    ] + all_crate_deps(
+        normal_dev = True,
+    ),
+)
+
+rust_doc(
+    name = "rustdoc",
+    crate = ":cargo_bazel",
+    visibility = ["//visibility:public"],
+)
+
+# `rust_doc_test` does not currently work. See:
+# https://github.com/bazelbuild/rules_rust/issues/980
+#
+# rust_doc_test(
+#     name = "rustdoc_test",
+#     crate = ":cargo_bazel",
+# )
diff --git a/third_party/rules_rust/crate_universe/Cargo.Bazel.lock b/third_party/rules_rust/crate_universe/Cargo.Bazel.lock
new file mode 100644
index 0000000..2e894c1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/Cargo.Bazel.lock
@@ -0,0 +1,8022 @@
+{
+  "checksum": "f8ab2b6622cba7bb41ac5eb5642bdfcb0bf5c1bd74c34e0245943b445b5c058c",
+  "crates": {
+    "aho-corasick 0.7.18": {
+      "name": "aho-corasick",
+      "version": "0.7.18",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+          "sha256": "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "aho_corasick",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "aho_corasick",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.18"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "anyhow 1.0.55": {
+      "name": "anyhow",
+      "version": "1.0.55",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/anyhow/1.0.55/download",
+          "sha256": "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "anyhow",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "anyhow",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "anyhow 1.0.55",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.55"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "atty 0.2.14": {
+      "name": "atty",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atty/0.2.14/download",
+          "sha256": "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atty",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atty",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"hermit\")": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "license": "MIT"
+    },
+    "autocfg 1.1.0": {
+      "name": "autocfg",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/autocfg/1.1.0/download",
+          "sha256": "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "autocfg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "autocfg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "block-buffer 0.10.2": {
+      "name": "block-buffer",
+      "version": "0.10.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/block-buffer/0.10.2/download",
+          "sha256": "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "block_buffer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "block_buffer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "generic_array"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "block-buffer 0.7.3": {
+      "name": "block-buffer",
+      "version": "0.7.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/block-buffer/0.7.3/download",
+          "sha256": "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "block_buffer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "block_buffer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "block-padding 0.1.5",
+              "target": "block_padding"
+            },
+            {
+              "id": "byte-tools 0.3.1",
+              "target": "byte_tools"
+            },
+            {
+              "id": "byteorder 1.4.3",
+              "target": "byteorder"
+            },
+            {
+              "id": "generic-array 0.12.4",
+              "target": "generic_array"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.7.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "block-padding 0.1.5": {
+      "name": "block-padding",
+      "version": "0.1.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/block-padding/0.1.5/download",
+          "sha256": "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "block_padding",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "block_padding",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "byte-tools 0.3.1",
+              "target": "byte_tools"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "bstr 0.2.17": {
+      "name": "bstr",
+      "version": "0.2.17",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bstr/0.2.17/download",
+          "sha256": "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bstr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bstr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.17"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "byte-tools 0.3.1": {
+      "name": "byte-tools",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/byte-tools/0.3.1/download",
+          "sha256": "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "byte_tools",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "byte_tools",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "byteorder 1.4.3": {
+      "name": "byteorder",
+      "version": "1.4.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/byteorder/1.4.3/download",
+          "sha256": "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "byteorder",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "byteorder",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.4.3"
+      },
+      "license": "Unlicense OR MIT"
+    },
+    "camino 1.0.7": {
+      "name": "camino",
+      "version": "1.0.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/camino/1.0.7/download",
+          "sha256": "6f3132262930b0522068049f5870a856ab8affc80c70d08b6ecb785771a6fc23"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "camino",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "camino",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "serde",
+          "serde1"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "camino 1.0.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "cargo-bazel 0.0.28": {
+      "name": "cargo-bazel",
+      "version": "0.0.28",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cargo_bazel",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "cargo-bazel",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cargo_bazel",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "cargo",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "anyhow 1.0.55",
+              "target": "anyhow"
+            },
+            {
+              "id": "cargo-lock 7.0.1",
+              "target": "cargo_lock"
+            },
+            {
+              "id": "cargo-platform 0.1.2",
+              "target": "cargo_platform"
+            },
+            {
+              "id": "cargo_metadata 0.14.2",
+              "target": "cargo_metadata"
+            },
+            {
+              "id": "cargo_toml 0.11.4",
+              "target": "cargo_toml"
+            },
+            {
+              "id": "cfg-expr 0.10.2",
+              "target": "cfg_expr"
+            },
+            {
+              "id": "clap 3.1.5",
+              "target": "clap"
+            },
+            {
+              "id": "crates-index 0.18.7",
+              "target": "crates_index"
+            },
+            {
+              "id": "hex 0.4.3",
+              "target": "hex"
+            },
+            {
+              "id": "pathdiff 0.2.1",
+              "target": "pathdiff"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "semver 1.0.6",
+              "target": "semver"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "sha2 0.10.2",
+              "target": "sha2"
+            },
+            {
+              "id": "tempfile 3.3.0",
+              "target": "tempfile"
+            },
+            {
+              "id": "tera 1.15.0",
+              "target": "tera"
+            },
+            {
+              "id": "textwrap 0.14.2",
+              "target": "textwrap"
+            },
+            {
+              "id": "toml 0.5.8",
+              "target": "toml"
+            }
+          ],
+          "selects": {}
+        },
+        "deps_dev": {
+          "common": [
+            {
+              "id": "spectral 0.6.0",
+              "target": "spectral"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.0.28"
+      },
+      "license": null
+    },
+    "cargo-lock 7.0.1": {
+      "name": "cargo-lock",
+      "version": "7.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cargo-lock/7.0.1/download",
+          "sha256": "7fb04b88bd5b2036e30704f95c6ee16f3b5ca3b4ca307da2889d9006648e5c88"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cargo_lock",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "cargo-lock",
+            "crate_root": "src/bin/cargo-lock/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cargo_lock",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "semver 1.0.6",
+              "target": "semver"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "toml 0.5.8",
+              "target": "toml"
+            },
+            {
+              "id": "url 2.2.2",
+              "target": "url"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "7.0.1"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "cargo-platform 0.1.2": {
+      "name": "cargo-platform",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cargo-platform/0.1.2/download",
+          "sha256": "cbdb825da8a5df079a43676dbe042702f1707b1109f713a01420fbb4cc71fa27"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cargo_platform",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cargo_platform",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "cargo_metadata 0.14.2": {
+      "name": "cargo_metadata",
+      "version": "0.14.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cargo_metadata/0.14.2/download",
+          "sha256": "4acbb09d9ee8e23699b9634375c72795d095bf268439da88562cf9b501f181fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cargo_metadata",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cargo_metadata",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "camino 1.0.7",
+              "target": "camino"
+            },
+            {
+              "id": "cargo-platform 0.1.2",
+              "target": "cargo_platform"
+            },
+            {
+              "id": "semver 1.0.6",
+              "target": "semver"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.14.2"
+      },
+      "license": "MIT"
+    },
+    "cargo_toml 0.11.4": {
+      "name": "cargo_toml",
+      "version": "0.11.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cargo_toml/0.11.4/download",
+          "sha256": "4e270ef0cd868745878982f7ce470aa898d0d4bb248af67f0cf66f54617913ef"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cargo_toml",
+            "crate_root": "src/cargo_toml.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cargo_toml",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "toml 0.5.8",
+              "target": "toml"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "serde_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.11.4"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "cc 1.0.73": {
+      "name": "cc",
+      "version": "1.0.73",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cc/1.0.73/download",
+          "sha256": "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "gcc-shim",
+            "crate_root": "src/bin/gcc-shim.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "jobserver",
+          "parallel"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "jobserver 0.1.24",
+              "target": "jobserver"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.73"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "cfg-expr 0.10.2": {
+      "name": "cfg-expr",
+      "version": "0.10.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-expr/0.10.2/download",
+          "sha256": "5e068cb2806bbc15b439846dc16c5f89f8599f2c3e4d73d4449d38f9b2f0b6c5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_expr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_expr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smallvec 1.8.0",
+              "target": "smallvec"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "chrono 0.4.19": {
+      "name": "chrono",
+      "version": "0.4.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/chrono/0.4.19/download",
+          "sha256": "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "chrono",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "chrono",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clock",
+          "libc",
+          "std",
+          "winapi"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.4.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "chrono-tz 0.6.1": {
+      "name": "chrono-tz",
+      "version": "0.6.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/chrono-tz/0.6.1/download",
+          "sha256": "58549f1842da3080ce63002102d5bc954c7bc843d4f47818e642abdc36253552"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "chrono_tz",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "chrono_tz",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "chrono 0.4.19",
+              "target": "chrono"
+            },
+            {
+              "id": "chrono-tz 0.6.1",
+              "target": "build_script_build"
+            },
+            {
+              "id": "phf 0.10.1",
+              "target": "phf"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.6.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "chrono-tz-build 0.0.2",
+              "target": "chrono_tz_build"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "chrono-tz-build 0.0.2": {
+      "name": "chrono-tz-build",
+      "version": "0.0.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/chrono-tz-build/0.0.2/download",
+          "sha256": "db058d493fb2f65f41861bfed7e3fe6335264a9f0f92710cab5bdf01fef09069"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "chrono_tz_build",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "chrono_tz_build",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "parse-zoneinfo 0.3.0",
+              "target": "parse_zoneinfo"
+            },
+            {
+              "id": "phf 0.10.1",
+              "target": "phf"
+            },
+            {
+              "id": "phf_codegen 0.10.0",
+              "target": "phf_codegen"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.0.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "clap 3.1.5": {
+      "name": "clap",
+      "version": "3.1.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap/3.1.5/download",
+          "sha256": "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "clap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "atty",
+          "clap_derive",
+          "color",
+          "default",
+          "derive",
+          "env",
+          "lazy_static",
+          "std",
+          "strsim",
+          "suggestions",
+          "termcolor"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "indexmap"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "os_str_bytes 6.0.0",
+              "target": "os_str_bytes"
+            },
+            {
+              "id": "strsim 0.10.0",
+              "target": "strsim"
+            },
+            {
+              "id": "termcolor 1.1.3",
+              "target": "termcolor"
+            },
+            {
+              "id": "textwrap 0.15.0",
+              "target": "textwrap"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "clap_derive 3.1.4",
+              "target": "clap_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "3.1.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "clap_derive 3.1.4": {
+      "name": "clap_derive",
+      "version": "3.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap_derive/3.1.4/download",
+          "sha256": "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "clap_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "heck 0.4.0",
+              "target": "heck"
+            },
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "proc_macro_error"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "3.1.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "cpufeatures 0.2.1": {
+      "name": "cpufeatures",
+      "version": "0.2.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cpufeatures/0.2.1/download",
+          "sha256": "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cpufeatures",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cpufeatures",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "aarch64-apple-darwin": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.2.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "crates-index 0.18.7": {
+      "name": "crates-index",
+      "version": "0.18.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crates-index/0.18.7/download",
+          "sha256": "0044896374c388ccbf1497dad6384bf6111dbcad9d7069506df7450ce9b62ea3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crates_index",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crates_index",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "git2 0.14.1",
+              "target": "git2"
+            },
+            {
+              "id": "hex 0.4.3",
+              "target": "hex"
+            },
+            {
+              "id": "home 0.5.3",
+              "target": "home"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "rustc-hash 1.1.0",
+              "target": "rustc_hash"
+            },
+            {
+              "id": "semver 1.0.6",
+              "target": "semver"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "smartstring 1.0.0",
+              "target": "smartstring"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "serde_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.18.7"
+      },
+      "license": "Apache-2.0"
+    },
+    "cross_installer 0.1.0": {
+      "name": "cross_installer",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Binary": {
+            "crate_name": "cross_installer",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": null,
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 3.1.5",
+              "target": "clap"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "crossbeam-utils 0.8.7": {
+      "name": "crossbeam-utils",
+      "version": "0.8.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crossbeam-utils/0.8.7/download",
+          "sha256": "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crossbeam_utils",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crossbeam_utils",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lazy_static",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "crypto-common 0.1.3": {
+      "name": "crypto-common",
+      "version": "0.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crypto-common/0.1.3/download",
+          "sha256": "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crypto_common",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crypto_common",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "generic_array"
+            },
+            {
+              "id": "typenum 1.15.0",
+              "target": "typenum"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "deunicode 0.4.3": {
+      "name": "deunicode",
+      "version": "0.4.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/deunicode/0.4.3/download",
+          "sha256": "850878694b7933ca4c9569d30a34b55031b9b139ee1fc7b94a527c4ef960d690"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "deunicode",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "deunicode",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.4.3"
+      },
+      "license": "BSD-3-Clause"
+    },
+    "digest 0.10.3": {
+      "name": "digest",
+      "version": "0.10.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/digest/0.10.3/download",
+          "sha256": "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "digest",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "digest",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "block-buffer",
+          "core-api",
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "block-buffer 0.10.2",
+              "target": "block_buffer"
+            },
+            {
+              "id": "crypto-common 0.1.3",
+              "target": "crypto_common"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "digest 0.8.1": {
+      "name": "digest",
+      "version": "0.8.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/digest/0.8.1/download",
+          "sha256": "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "digest",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "digest",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.12.4",
+              "target": "generic_array"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.8.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "fake-simd 0.1.2": {
+      "name": "fake-simd",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fake-simd/0.1.2/download",
+          "sha256": "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fake_simd",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fake_simd",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "fastrand 1.7.0": {
+      "name": "fastrand",
+      "version": "1.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fastrand/1.7.0/download",
+          "sha256": "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fastrand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fastrand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_arch = \"wasm32\")": [
+              {
+                "id": "instant 0.1.12",
+                "target": "instant"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.7.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "fnv 1.0.7": {
+      "name": "fnv",
+      "version": "1.0.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fnv/1.0.7/download",
+          "sha256": "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fnv",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fnv",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "1.0.7"
+      },
+      "license": "Apache-2.0 / MIT"
+    },
+    "form_urlencoded 1.0.1": {
+      "name": "form_urlencoded",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download",
+          "sha256": "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "form_urlencoded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "form_urlencoded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "fuchsia-cprng 0.1.1": {
+      "name": "fuchsia-cprng",
+      "version": "0.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fuchsia-cprng/0.1.1/download",
+          "sha256": "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fuchsia_cprng",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fuchsia_cprng",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.1"
+      },
+      "license": null
+    },
+    "generic-array 0.12.4": {
+      "name": "generic-array",
+      "version": "0.12.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/generic-array/0.12.4/download",
+          "sha256": "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "generic_array",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "generic_array",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "typenum 1.15.0",
+              "target": "typenum"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.12.4"
+      },
+      "license": "MIT"
+    },
+    "generic-array 0.14.5": {
+      "name": "generic-array",
+      "version": "0.14.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/generic-array/0.14.5/download",
+          "sha256": "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "generic_array",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "generic_array",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "more_lengths"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "build_script_build"
+            },
+            {
+              "id": "typenum 1.15.0",
+              "target": "typenum"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.14.5"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT"
+    },
+    "getrandom 0.2.5": {
+      "name": "getrandom",
+      "version": "0.2.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/getrandom/0.2.5/download",
+          "sha256": "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "getrandom",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "getrandom",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"wasi\")": [
+              {
+                "id": "wasi 0.10.2+wasi-snapshot-preview1",
+                "target": "wasi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.2.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "git2 0.14.1": {
+      "name": "git2",
+      "version": "0.14.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/git2/0.14.1/download",
+          "sha256": "6e7d3b96ec1fcaa8431cf04a4f1ef5caafe58d5cf7bcc31f09c1626adddb0ffe"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "git2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "git2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "libgit2-sys 0.13.1+1.4.2",
+              "target": "libgit2_sys"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "url 2.2.2",
+              "target": "url"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.14.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "globset 0.4.8": {
+      "name": "globset",
+      "version": "0.4.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/globset/0.4.8/download",
+          "sha256": "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "globset",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "globset",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "aho-corasick 0.7.18",
+              "target": "aho_corasick"
+            },
+            {
+              "id": "bstr 0.2.17",
+              "target": "bstr"
+            },
+            {
+              "id": "fnv 1.0.7",
+              "target": "fnv"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.8"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "globwalk 0.8.1": {
+      "name": "globwalk",
+      "version": "0.8.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/globwalk/0.8.1/download",
+          "sha256": "93e3af942408868f6934a7b85134a3230832b9977cf66125df2f9edcfce4ddcc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "globwalk",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "globwalk",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "ignore 0.4.18",
+              "target": "ignore"
+            },
+            {
+              "id": "walkdir 2.3.2",
+              "target": "walkdir"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.8.1"
+      },
+      "license": "MIT"
+    },
+    "hashbrown 0.11.2": {
+      "name": "hashbrown",
+      "version": "0.11.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hashbrown/0.11.2/download",
+          "sha256": "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hashbrown",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hashbrown",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "raw"
+        ],
+        "edition": "2018",
+        "version": "0.11.2"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "heck 0.4.0": {
+      "name": "heck",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/heck/0.4.0/download",
+          "sha256": "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "heck",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "heck",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "0.4.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "hex 0.4.3": {
+      "name": "hex",
+      "version": "0.4.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hex/0.4.3/download",
+          "sha256": "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "serde",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "home 0.5.3": {
+      "name": "home",
+      "version": "0.5.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/home/0.5.3/download",
+          "sha256": "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "home",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "home",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.5.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "humansize 1.1.1": {
+      "name": "humansize",
+      "version": "1.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/humansize/1.1.1/download",
+          "sha256": "02296996cb8796d7c6e3bc2d9211b7802812d36999a51bb754123ead7d37d026"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "humansize",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "humansize",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "idna 0.2.3": {
+      "name": "idna",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/idna/0.2.3/download",
+          "sha256": "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "idna",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "idna",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "unicode-bidi 0.3.7",
+              "target": "unicode_bidi"
+            },
+            {
+              "id": "unicode-normalization 0.1.19",
+              "target": "unicode_normalization"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "ignore 0.4.18": {
+      "name": "ignore",
+      "version": "0.4.18",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ignore/0.4.18/download",
+          "sha256": "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ignore",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ignore",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "crossbeam_utils"
+            },
+            {
+              "id": "globset 0.4.8",
+              "target": "globset"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "same-file 1.0.6",
+              "target": "same_file"
+            },
+            {
+              "id": "thread_local 1.1.4",
+              "target": "thread_local"
+            },
+            {
+              "id": "walkdir 2.3.2",
+              "target": "walkdir"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.4.18"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "indexmap 1.8.0": {
+      "name": "indexmap",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/indexmap/1.8.0/download",
+          "sha256": "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "indexmap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "indexmap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "hashbrown 0.11.2",
+              "target": "hashbrown"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "instant 0.1.12": {
+      "name": "instant",
+      "version": "0.1.12",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/instant/0.1.12/download",
+          "sha256": "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "instant",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "instant",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.12"
+      },
+      "license": "BSD-3-Clause"
+    },
+    "itoa 1.0.1": {
+      "name": "itoa",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/itoa/1.0.1/download",
+          "sha256": "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "itoa",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "itoa",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "jobserver 0.1.24": {
+      "name": "jobserver",
+      "version": "0.1.24",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/jobserver/0.1.24/download",
+          "sha256": "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "jobserver",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "jobserver",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.24"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "lazy_static 1.4.0": {
+      "name": "lazy_static",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+          "sha256": "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lazy_static",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lazy_static",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "libgit2-sys 0.13.1+1.4.2": {
+      "name": "libgit2-sys",
+      "version": "0.13.1+1.4.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libgit2-sys/0.13.1+1.4.2/download",
+          "sha256": "43e598aa7a4faedf1ea1b4608f582b06f0f40211eec551b7ef36019ae3f62def"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libgit2_sys",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libgit2_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "libz-sys 1.1.3",
+              "target": "libz_sys"
+            }
+          ],
+          "selects": {}
+        },
+        "extra_deps": [
+          "@libgit2"
+        ],
+        "edition": "2018",
+        "version": "0.13.1+1.4.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libz-sys 1.1.3": {
+      "name": "libz-sys",
+      "version": "1.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libz-sys/1.1.3/download",
+          "sha256": "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libz_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libz_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "libc"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "extra_deps": [
+          "@zlib"
+        ],
+        "edition": "2015",
+        "version": "1.1.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "log 0.4.14": {
+      "name": "log",
+      "version": "0.4.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/log/0.4.14/download",
+          "sha256": "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "maplit 1.0.2": {
+      "name": "maplit",
+      "version": "1.0.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/maplit/1.0.2/download",
+          "sha256": "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "maplit",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "maplit",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.0.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "matches 0.1.9": {
+      "name": "matches",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/matches/0.1.9/download",
+          "sha256": "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "matches",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "matches",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT"
+    },
+    "memchr 2.4.1": {
+      "name": "memchr",
+      "version": "2.4.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+          "sha256": "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "memchr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "memchr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.4.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Unlicense/MIT"
+    },
+    "num 0.1.42": {
+      "name": "num",
+      "version": "0.1.42",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num/0.1.42/download",
+          "sha256": "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "bigint",
+          "complex",
+          "default",
+          "num-bigint",
+          "num-complex",
+          "num-rational",
+          "rational",
+          "rustc-serialize"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-bigint 0.1.44",
+              "target": "num_bigint"
+            },
+            {
+              "id": "num-complex 0.1.43",
+              "target": "num_complex"
+            },
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-iter 0.1.42",
+              "target": "num_iter"
+            },
+            {
+              "id": "num-rational 0.1.42",
+              "target": "num_rational"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.42"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "num-bigint 0.1.44": {
+      "name": "num-bigint",
+      "version": "0.1.44",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-bigint/0.1.44/download",
+          "sha256": "e63899ad0da84ce718c14936262a41cee2c79c981fc0a0e7c7beb47d5a07e8c1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_bigint",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_bigint",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "rand",
+          "rustc-serialize"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            },
+            {
+              "id": "rand 0.4.6",
+              "target": "rand"
+            },
+            {
+              "id": "rustc-serialize 0.3.24",
+              "target": "rustc_serialize"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.44"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "num-complex 0.1.43": {
+      "name": "num-complex",
+      "version": "0.1.43",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-complex/0.1.43/download",
+          "sha256": "b288631d7878aaf59442cffd36910ea604ecd7745c36054328595114001c9656"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_complex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_complex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "rustc-serialize"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            },
+            {
+              "id": "rustc-serialize 0.3.24",
+              "target": "rustc_serialize"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.43"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "num-integer 0.1.44": {
+      "name": "num-integer",
+      "version": "0.1.44",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-integer/0.1.44/download",
+          "sha256": "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_integer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_integer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "build_script_build"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.44"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num-iter 0.1.42": {
+      "name": "num-iter",
+      "version": "0.1.42",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-iter/0.1.42/download",
+          "sha256": "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_iter",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_iter",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-iter 0.1.42",
+              "target": "build_script_build"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.42"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num-rational 0.1.42": {
+      "name": "num-rational",
+      "version": "0.1.42",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-rational/0.1.42/download",
+          "sha256": "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_rational",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_rational",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "bigint",
+          "default",
+          "num-bigint",
+          "rustc-serialize"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-bigint 0.1.44",
+              "target": "num_bigint"
+            },
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            },
+            {
+              "id": "rustc-serialize 0.3.24",
+              "target": "rustc_serialize"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.42"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "num-traits 0.2.14": {
+      "name": "num-traits",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-traits/0.2.14/download",
+          "sha256": "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_traits",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_traits",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-traits 0.2.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num_cpus 1.13.1": {
+      "name": "num_cpus",
+      "version": "1.13.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num_cpus/1.13.1/download",
+          "sha256": "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_cpus",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_cpus",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(not(windows))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "1.13.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "once_cell 1.9.0": {
+      "name": "once_cell",
+      "version": "1.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/once_cell/1.9.0/download",
+          "sha256": "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "once_cell",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "once_cell",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "race",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.9.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "opaque-debug 0.2.3": {
+      "name": "opaque-debug",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/opaque-debug/0.2.3/download",
+          "sha256": "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "opaque_debug",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "opaque_debug",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "os_str_bytes 6.0.0": {
+      "name": "os_str_bytes",
+      "version": "6.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/os_str_bytes/6.0.0/download",
+          "sha256": "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "os_str_bytes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "os_str_bytes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "memchr",
+          "raw_os_str"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "6.0.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "parse-zoneinfo 0.3.0": {
+      "name": "parse-zoneinfo",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parse-zoneinfo/0.3.0/download",
+          "sha256": "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parse_zoneinfo",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parse_zoneinfo",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "pathdiff 0.2.1": {
+      "name": "pathdiff",
+      "version": "0.2.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pathdiff/0.2.1/download",
+          "sha256": "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pathdiff",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pathdiff",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.2.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "percent-encoding 2.1.0": {
+      "name": "percent-encoding",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/percent-encoding/2.1.0/download",
+          "sha256": "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "percent_encoding",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "percent_encoding",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "2.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pest 2.1.3": {
+      "name": "pest",
+      "version": "2.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pest/2.1.3/download",
+          "sha256": "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pest",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pest",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ucd-trie 0.1.3",
+              "target": "ucd_trie"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "2.1.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pest_derive 2.1.0": {
+      "name": "pest_derive",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pest_derive/2.1.0/download",
+          "sha256": "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "pest_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pest_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "pest 2.1.3",
+              "target": "pest"
+            },
+            {
+              "id": "pest_generator 2.1.3",
+              "target": "pest_generator"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "2.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pest_generator 2.1.3": {
+      "name": "pest_generator",
+      "version": "2.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pest_generator/2.1.3/download",
+          "sha256": "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pest_generator",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pest_generator",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "pest 2.1.3",
+              "target": "pest"
+            },
+            {
+              "id": "pest_meta 2.1.3",
+              "target": "pest_meta"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "2.1.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pest_meta 2.1.3": {
+      "name": "pest_meta",
+      "version": "2.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pest_meta/2.1.3/download",
+          "sha256": "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pest_meta",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pest_meta",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "maplit 1.0.2",
+              "target": "maplit"
+            },
+            {
+              "id": "pest 2.1.3",
+              "target": "pest"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "2.1.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "phf 0.10.1": {
+      "name": "phf",
+      "version": "0.10.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/phf/0.10.1/download",
+          "sha256": "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "phf",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "phf",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "uncased"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "phf_shared 0.10.0",
+              "target": "phf_shared"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.1"
+      },
+      "license": "MIT"
+    },
+    "phf_codegen 0.10.0": {
+      "name": "phf_codegen",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/phf_codegen/0.10.0/download",
+          "sha256": "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "phf_codegen",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "phf_codegen",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "phf_generator 0.10.0",
+              "target": "phf_generator"
+            },
+            {
+              "id": "phf_shared 0.10.0",
+              "target": "phf_shared"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "phf_generator 0.10.0": {
+      "name": "phf_generator",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/phf_generator/0.10.0/download",
+          "sha256": "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "phf_generator",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "gen_hash_test",
+            "crate_root": "src/bin/gen_hash_test.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "phf_generator",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "phf_shared 0.10.0",
+              "target": "phf_shared"
+            },
+            {
+              "id": "rand 0.8.5",
+              "target": "rand"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "phf_shared 0.10.0": {
+      "name": "phf_shared",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/phf_shared/0.10.0/download",
+          "sha256": "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "phf_shared",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "phf_shared",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std",
+          "uncased"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "siphasher 0.3.9",
+              "target": "siphasher"
+            },
+            {
+              "id": "uncased 0.9.6",
+              "target": "uncased"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "pkg-config 0.3.24": {
+      "name": "pkg-config",
+      "version": "0.3.24",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pkg-config/0.3.24/download",
+          "sha256": "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pkg_config",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pkg_config",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.24"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "ppv-lite86 0.2.16": {
+      "name": "ppv-lite86",
+      "version": "0.2.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ppv-lite86/0.2.16/download",
+          "sha256": "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ppv_lite86",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ppv_lite86",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "simd",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.2.16"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "proc-macro-error 1.0.4": {
+      "name": "proc-macro-error",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error/1.0.4/download",
+          "sha256": "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro_error",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "syn",
+          "syn-error"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "proc_macro_error_attr"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro-error-attr 1.0.4": {
+      "name": "proc-macro-error-attr",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error-attr/1.0.4/download",
+          "sha256": "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "proc_macro_error_attr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error_attr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro2 1.0.36": {
+      "name": "proc-macro2",
+      "version": "1.0.36",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro2/1.0.36/download",
+          "sha256": "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.36"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "quote 1.0.15": {
+      "name": "quote",
+      "version": "1.0.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/quote/1.0.15/download",
+          "sha256": "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "quote",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "quote",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.15"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand 0.4.6": {
+      "name": "rand",
+      "version": "0.4.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand/0.4.6/download",
+          "sha256": "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "libc",
+          "std"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_env = \"sgx\")": [
+              {
+                "id": "rand_core 0.3.1",
+                "target": "rand_core"
+              },
+              {
+                "id": "rdrand 0.4.0",
+                "target": "rdrand"
+              }
+            ],
+            "cfg(target_os = \"fuchsia\")": [
+              {
+                "id": "fuchsia-cprng 0.1.1",
+                "target": "fuchsia_cprng"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.4.6"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rand 0.8.5": {
+      "name": "rand",
+      "version": "0.8.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand/0.8.5/download",
+          "sha256": "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "getrandom",
+          "libc",
+          "rand_chacha",
+          "small_rng",
+          "std",
+          "std_rng"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_chacha 0.3.1",
+              "target": "rand_chacha"
+            },
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_chacha 0.3.1": {
+      "name": "rand_chacha",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_chacha/0.3.1/download",
+          "sha256": "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_chacha",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_chacha",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ppv-lite86 0.2.16",
+              "target": "ppv_lite86"
+            },
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_core 0.3.1": {
+      "name": "rand_core",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.3.1/download",
+          "sha256": "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_core 0.4.2",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.3.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rand_core 0.4.2": {
+      "name": "rand_core",
+      "version": "0.4.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.4.2/download",
+          "sha256": "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.4.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rand_core 0.6.3": {
+      "name": "rand_core",
+      "version": "0.6.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.6.3/download",
+          "sha256": "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "getrandom",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "getrandom 0.2.5",
+              "target": "getrandom"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.6.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rdrand 0.4.0": {
+      "name": "rdrand",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rdrand/0.4.0/download",
+          "sha256": "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rdrand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rdrand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_core 0.3.1",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "license": "ISC"
+    },
+    "redox_syscall 0.2.11": {
+      "name": "redox_syscall",
+      "version": "0.2.11",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/redox_syscall/0.2.11/download",
+          "sha256": "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syscall",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syscall",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.11"
+      },
+      "license": "MIT"
+    },
+    "regex 1.5.4": {
+      "name": "regex",
+      "version": "1.5.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex/1.5.4/download",
+          "sha256": "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "aho-corasick",
+          "default",
+          "memchr",
+          "perf",
+          "perf-cache",
+          "perf-dfa",
+          "perf-inline",
+          "perf-literal",
+          "std",
+          "unicode",
+          "unicode-age",
+          "unicode-bool",
+          "unicode-case",
+          "unicode-gencat",
+          "unicode-perl",
+          "unicode-script",
+          "unicode-segment"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "aho-corasick 0.7.18",
+              "target": "aho_corasick"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "regex-syntax 0.6.25",
+              "target": "regex_syntax"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex-syntax 0.6.25": {
+      "name": "regex-syntax",
+      "version": "0.6.25",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+          "sha256": "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex_syntax",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex_syntax",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "unicode",
+          "unicode-age",
+          "unicode-bool",
+          "unicode-case",
+          "unicode-gencat",
+          "unicode-perl",
+          "unicode-script",
+          "unicode-segment"
+        ],
+        "edition": "2018",
+        "version": "0.6.25"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "remove_dir_all 0.5.3": {
+      "name": "remove_dir_all",
+      "version": "0.5.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/remove_dir_all/0.5.3/download",
+          "sha256": "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "remove_dir_all",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "remove_dir_all",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.5.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rustc-hash 1.1.0": {
+      "name": "rustc-hash",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rustc-hash/1.1.0/download",
+          "sha256": "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rustc_hash",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rustc_hash",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "rustc-serialize 0.3.24": {
+      "name": "rustc-serialize",
+      "version": "0.3.24",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rustc-serialize/0.3.24/download",
+          "sha256": "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rustc_serialize",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rustc_serialize",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.24"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "ryu 1.0.9": {
+      "name": "ryu",
+      "version": "1.0.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ryu/1.0.9/download",
+          "sha256": "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ryu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ryu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.9"
+      },
+      "license": "Apache-2.0 OR BSL-1.0"
+    },
+    "same-file 1.0.6": {
+      "name": "same-file",
+      "version": "1.0.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/same-file/1.0.6/download",
+          "sha256": "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "same_file",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "same_file",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.0.6"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "semver 1.0.6": {
+      "name": "semver",
+      "version": "1.0.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/semver/1.0.6/download",
+          "sha256": "a4a3381e03edd24287172047536f20cabde766e2cd3e65e6b00fb3af51c4f38d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "semver",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "semver",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "serde",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "semver 1.0.6",
+              "target": "build_script_build"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.6"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde 1.0.136": {
+      "name": "serde",
+      "version": "1.0.136",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde/1.0.136/download",
+          "sha256": "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "derive",
+          "rc",
+          "serde_derive",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "serde_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.136"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_derive 1.0.136": {
+      "name": "serde_derive",
+      "version": "1.0.136",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_derive/1.0.136/download",
+          "sha256": "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "serde_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "build_script_build"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.0.136"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_json 1.0.79": {
+      "name": "serde_json",
+      "version": "1.0.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_json/1.0.79/download",
+          "sha256": "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_json",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_json",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std",
+          "unbounded_depth"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "ryu 1.0.9",
+              "target": "ryu"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.79"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "sha-1 0.8.2": {
+      "name": "sha-1",
+      "version": "0.8.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/sha-1/0.8.2/download",
+          "sha256": "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "sha1",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "sha1",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "block-buffer 0.7.3",
+              "target": "block_buffer"
+            },
+            {
+              "id": "digest 0.8.1",
+              "target": "digest"
+            },
+            {
+              "id": "fake-simd 0.1.2",
+              "target": "fake_simd"
+            },
+            {
+              "id": "opaque-debug 0.2.3",
+              "target": "opaque_debug"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.8.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "sha2 0.10.2": {
+      "name": "sha2",
+      "version": "0.10.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/sha2/0.10.2/download",
+          "sha256": "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "sha2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "sha2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "digest 0.10.3",
+              "target": "digest"
+            }
+          ],
+          "selects": {
+            "cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))": [
+              {
+                "id": "cpufeatures 0.2.1",
+                "target": "cpufeatures"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.10.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "siphasher 0.3.9": {
+      "name": "siphasher",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/siphasher/0.3.9/download",
+          "sha256": "a86232ab60fa71287d7f2ddae4a7073f6b7aac33631c3015abb556f08c6d0a3e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "siphasher",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "siphasher",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "slug 0.1.4": {
+      "name": "slug",
+      "version": "0.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/slug/0.1.4/download",
+          "sha256": "b3bc762e6a4b6c6fcaade73e77f9ebc6991b676f88bb2358bddb56560f073373"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "slug",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "slug",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "deunicode 0.4.3",
+              "target": "deunicode"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.4"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "smallvec 1.8.0": {
+      "name": "smallvec",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smallvec/1.8.0/download",
+          "sha256": "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smallvec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smallvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "smartstring 1.0.0": {
+      "name": "smartstring",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smartstring/1.0.0/download",
+          "sha256": "ea958ad90cacc8ece7f238fde3671e1b350ee1741964edf2a22fd16f60224163"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smartstring",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smartstring",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "serde",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "static_assertions 1.1.0",
+              "target": "static_assertions"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2021",
+        "version": "1.0.0"
+      },
+      "license": "MPL-2.0+"
+    },
+    "smawk 0.3.1": {
+      "name": "smawk",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smawk/0.3.1/download",
+          "sha256": "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smawk",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smawk",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "spectral 0.6.0": {
+      "name": "spectral",
+      "version": "0.6.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/spectral/0.6.0/download",
+          "sha256": "ae3c15181f4b14e52eeaac3efaeec4d2764716ce9c86da0c934c3e318649c5ba"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "spectral",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "spectral",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "num"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num 0.1.42",
+              "target": "num"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.6.0"
+      },
+      "license": "Apache-2.0"
+    },
+    "static_assertions 1.1.0": {
+      "name": "static_assertions",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/static_assertions/1.1.0/download",
+          "sha256": "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "static_assertions",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "static_assertions",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "strsim 0.10.0": {
+      "name": "strsim",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/strsim/0.10.0/download",
+          "sha256": "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "strsim",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "strsim",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "syn 1.0.86": {
+      "name": "syn",
+      "version": "1.0.86",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/syn/1.0.86/download",
+          "sha256": "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clone-impls",
+          "default",
+          "derive",
+          "full",
+          "parsing",
+          "printing",
+          "proc-macro",
+          "quote"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.86"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "tempfile 3.3.0": {
+      "name": "tempfile",
+      "version": "3.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tempfile/3.3.0/download",
+          "sha256": "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tempfile",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tempfile",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "fastrand 1.7.0",
+              "target": "fastrand"
+            },
+            {
+              "id": "remove_dir_all 0.5.3",
+              "target": "remove_dir_all"
+            }
+          ],
+          "selects": {
+            "cfg(any(unix, target_os = \"wasi\"))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(target_os = \"redox\")": [
+              {
+                "id": "redox_syscall 0.2.11",
+                "target": "syscall"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "3.3.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "tera 1.15.0": {
+      "name": "tera",
+      "version": "1.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tera/1.15.0/download",
+          "sha256": "d3cac831b615c25bcef632d1cabf864fa05813baad3d526829db18eb70e8b58d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tera",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tera",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "builtins",
+          "chrono",
+          "chrono-tz",
+          "default",
+          "humansize",
+          "percent-encoding",
+          "rand",
+          "slug"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "chrono 0.4.19",
+              "target": "chrono"
+            },
+            {
+              "id": "chrono-tz 0.6.1",
+              "target": "chrono_tz"
+            },
+            {
+              "id": "globwalk 0.8.1",
+              "target": "globwalk"
+            },
+            {
+              "id": "humansize 1.1.1",
+              "target": "humansize"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            },
+            {
+              "id": "pest 2.1.3",
+              "target": "pest"
+            },
+            {
+              "id": "rand 0.8.5",
+              "target": "rand"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "slug 0.1.4",
+              "target": "slug"
+            },
+            {
+              "id": "unic-segment 0.9.0",
+              "target": "unic_segment"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "pest_derive 2.1.0",
+              "target": "pest_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.15.0"
+      },
+      "license": "MIT"
+    },
+    "termcolor 1.1.3": {
+      "name": "termcolor",
+      "version": "1.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/termcolor/1.1.3/download",
+          "sha256": "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "termcolor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "termcolor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.1.3"
+      },
+      "license": "Unlicense OR MIT"
+    },
+    "textwrap 0.14.2": {
+      "name": "textwrap",
+      "version": "0.14.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.14.2/download",
+          "sha256": "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "smawk",
+          "unicode-linebreak",
+          "unicode-width"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smawk 0.3.1",
+              "target": "smawk"
+            },
+            {
+              "id": "unicode-linebreak 0.1.2",
+              "target": "unicode_linebreak"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.14.2"
+      },
+      "license": "MIT"
+    },
+    "textwrap 0.15.0": {
+      "name": "textwrap",
+      "version": "0.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.15.0/download",
+          "sha256": "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.15.0"
+      },
+      "license": "MIT"
+    },
+    "thread_local 1.1.4": {
+      "name": "thread_local",
+      "version": "1.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/thread_local/1.1.4/download",
+          "sha256": "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "thread_local",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "thread_local",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "once_cell 1.9.0",
+              "target": "once_cell"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.1.4"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "tinyvec 1.5.1": {
+      "name": "tinyvec",
+      "version": "1.5.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tinyvec/1.5.1/download",
+          "sha256": "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tinyvec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tinyvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "tinyvec_macros"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "tinyvec_macros 0.1.0",
+              "target": "tinyvec_macros"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.1"
+      },
+      "license": "Zlib OR Apache-2.0 OR MIT"
+    },
+    "tinyvec_macros 0.1.0": {
+      "name": "tinyvec_macros",
+      "version": "0.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tinyvec_macros/0.1.0/download",
+          "sha256": "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tinyvec_macros",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tinyvec_macros",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": "MIT OR Apache-2.0 OR Zlib"
+    },
+    "toml 0.5.8": {
+      "name": "toml",
+      "version": "0.5.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/toml/0.5.8/download",
+          "sha256": "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "toml",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "toml",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.5.8"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "typenum 1.15.0": {
+      "name": "typenum",
+      "version": "1.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/typenum/1.15.0/download",
+          "sha256": "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "typenum",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_main",
+            "crate_root": "build/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "typenum",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "typenum 1.15.0",
+              "target": "build_script_main"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.15.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "ucd-trie 0.1.3": {
+      "name": "ucd-trie",
+      "version": "0.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ucd-trie/0.1.3/download",
+          "sha256": "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ucd_trie",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ucd_trie",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.1.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "uncased 0.9.6": {
+      "name": "uncased",
+      "version": "0.9.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/uncased/0.9.6/download",
+          "sha256": "5baeed7327e25054889b9bd4f975f32e5f4c5d434042d59ab6cd4142c0a76ed0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "uncased",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "uncased",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "uncased 0.9.6",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.6"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "unic-char-property 0.9.0": {
+      "name": "unic-char-property",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-char-property/0.9.0/download",
+          "sha256": "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_char_property",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_char_property",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unic-char-range 0.9.0",
+              "target": "unic_char_range"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unic-char-range 0.9.0": {
+      "name": "unic-char-range",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-char-range/0.9.0/download",
+          "sha256": "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_char_range",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_char_range",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unic-common 0.9.0": {
+      "name": "unic-common",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-common/0.9.0/download",
+          "sha256": "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_common",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_common",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unic-segment 0.9.0": {
+      "name": "unic-segment",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-segment/0.9.0/download",
+          "sha256": "e4ed5d26be57f84f176157270c112ef57b86debac9cd21daaabbe56db0f88f23"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_segment",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_segment",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unic-ucd-segment 0.9.0",
+              "target": "unic_ucd_segment"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unic-ucd-segment 0.9.0": {
+      "name": "unic-ucd-segment",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-ucd-segment/0.9.0/download",
+          "sha256": "2079c122a62205b421f499da10f3ee0f7697f012f55b675e002483c73ea34700"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_ucd_segment",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_ucd_segment",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unic-char-property 0.9.0",
+              "target": "unic_char_property"
+            },
+            {
+              "id": "unic-char-range 0.9.0",
+              "target": "unic_char_range"
+            },
+            {
+              "id": "unic-ucd-version 0.9.0",
+              "target": "unic_ucd_version"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unic-ucd-version 0.9.0": {
+      "name": "unic-ucd-version",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unic-ucd-version/0.9.0/download",
+          "sha256": "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unic_ucd_version",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unic_ucd_version",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unic-common 0.9.0",
+              "target": "unic_common"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-bidi 0.3.7": {
+      "name": "unicode-bidi",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-bidi/0.3.7/download",
+          "sha256": "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_bidi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_bidi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "unicode-linebreak 0.1.2": {
+      "name": "unicode-linebreak",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-linebreak/0.1.2/download",
+          "sha256": "3a52dcaab0c48d931f7cc8ef826fa51690a08e1ea55117ef26f89864f532383f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_linebreak",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_linebreak",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unicode-linebreak 0.1.2",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0"
+    },
+    "unicode-normalization 0.1.19": {
+      "name": "unicode-normalization",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-normalization/0.1.19/download",
+          "sha256": "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_normalization",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_normalization",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "tinyvec 1.5.1",
+              "target": "tinyvec"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-width 0.1.9": {
+      "name": "unicode-width",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-width/0.1.9/download",
+          "sha256": "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_width",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_width",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-xid 0.2.2": {
+      "name": "unicode-xid",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+          "sha256": "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_xid",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_xid",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "url 2.2.2": {
+      "name": "url",
+      "version": "2.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/url/2.2.2/download",
+          "sha256": "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "url",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "url",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "form_urlencoded 1.0.1",
+              "target": "form_urlencoded"
+            },
+            {
+              "id": "idna 0.2.3",
+              "target": "idna"
+            },
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.2.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "urls_generator 0.1.0": {
+      "name": "urls_generator",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Binary": {
+            "crate_name": "urls_generator",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": null,
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 3.1.5",
+              "target": "clap"
+            },
+            {
+              "id": "hex 0.4.3",
+              "target": "hex"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "sha2 0.10.2",
+              "target": "sha2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "vcpkg 0.2.15": {
+      "name": "vcpkg",
+      "version": "0.2.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/vcpkg/0.2.15/download",
+          "sha256": "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "vcpkg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "vcpkg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.15"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "version_check 0.9.4": {
+      "name": "version_check",
+      "version": "0.9.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/version_check/0.9.4/download",
+          "sha256": "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "version_check",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "version_check",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.9.4"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "walkdir 2.3.2": {
+      "name": "walkdir",
+      "version": "2.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/walkdir/2.3.2/download",
+          "sha256": "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "walkdir",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "walkdir",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "same-file 1.0.6",
+              "target": "same_file"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              },
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "2.3.2"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "wasi 0.10.2+wasi-snapshot-preview1": {
+      "name": "wasi",
+      "version": "0.10.2+wasi-snapshot-preview1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download",
+          "sha256": "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.10.2+wasi-snapshot-preview1"
+      },
+      "license": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "consoleapi",
+          "errhandlingapi",
+          "fileapi",
+          "handleapi",
+          "minwinbase",
+          "minwindef",
+          "ntsecapi",
+          "processenv",
+          "profileapi",
+          "shlobj",
+          "std",
+          "timezoneapi",
+          "winbase",
+          "wincon",
+          "winerror",
+          "winnt"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-util 0.1.5": {
+      "name": "winapi-util",
+      "version": "0.1.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-util/0.1.5/download",
+          "sha256": "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.5"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    }
+  },
+  "binary_crates": [
+    "cargo-lock 7.0.1",
+    "cc 1.0.73",
+    "phf_generator 0.10.0"
+  ],
+  "workspace_members": {
+    "cargo-bazel 0.0.28": "crate_universe",
+    "cross_installer 0.1.0": "crate_universe/tools/cross_installer",
+    "urls_generator 0.1.0": "crate_universe/tools/urls_generator"
+  },
+  "conditions": {
+    "aarch64-apple-darwin": [
+      "aarch64-apple-darwin"
+    ],
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))": [
+      "aarch64-unknown-linux-gnu"
+    ],
+    "cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-pc-windows-msvc",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(any(unix, target_os = \"wasi\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(windows))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(target_arch = \"wasm32\")": [
+      "wasm32-unknown-unknown",
+      "wasm32-wasi"
+    ],
+    "cfg(target_env = \"sgx\")": [],
+    "cfg(target_os = \"fuchsia\")": [],
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"wasi\")": [
+      "wasm32-wasi"
+    ],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": []
+  }
+}
diff --git a/third_party/rules_rust/crate_universe/Cargo.lock b/third_party/rules_rust/crate_universe/Cargo.lock
new file mode 100644
index 0000000..a8ec086
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/Cargo.lock
@@ -0,0 +1,1426 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "block-buffer"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+dependencies = [
+ "block-padding",
+ "byte-tools",
+ "byteorder",
+ "generic-array 0.12.4",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+dependencies = [
+ "generic-array 0.14.5",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
+dependencies = [
+ "byte-tools",
+]
+
+[[package]]
+name = "bstr"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "byte-tools"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "camino"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f3132262930b0522068049f5870a856ab8affc80c70d08b6ecb785771a6fc23"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-bazel"
+version = "0.0.28"
+dependencies = [
+ "anyhow",
+ "cargo-lock",
+ "cargo-platform",
+ "cargo_metadata",
+ "cargo_toml",
+ "cfg-expr",
+ "clap",
+ "crates-index",
+ "hex",
+ "pathdiff",
+ "regex",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2",
+ "spectral",
+ "tempfile",
+ "tera",
+ "textwrap 0.14.2",
+ "toml",
+]
+
+[[package]]
+name = "cargo-lock"
+version = "7.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fb04b88bd5b2036e30704f95c6ee16f3b5ca3b4ca307da2889d9006648e5c88"
+dependencies = [
+ "semver",
+ "serde",
+ "toml",
+ "url",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbdb825da8a5df079a43676dbe042702f1707b1109f713a01420fbb4cc71fa27"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4acbb09d9ee8e23699b9634375c72795d095bf268439da88562cf9b501f181fa"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e270ef0cd868745878982f7ce470aa898d0d4bb248af67f0cf66f54617913ef"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "toml",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+dependencies = [
+ "jobserver",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e068cb2806bbc15b439846dc16c5f89f8599f2c3e4d73d4449d38f9b2f0b6c5"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+dependencies = [
+ "libc",
+ "num-integer",
+ "num-traits",
+ "winapi",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58549f1842da3080ce63002102d5bc954c7bc843d4f47818e642abdc36253552"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db058d493fb2f65f41861bfed7e3fe6335264a9f0f92710cab5bdf01fef09069"
+dependencies = [
+ "parse-zoneinfo",
+ "phf",
+ "phf_codegen",
+]
+
+[[package]]
+name = "clap"
+version = "3.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312"
+dependencies = [
+ "atty",
+ "bitflags",
+ "clap_derive",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "strsim",
+ "termcolor",
+ "textwrap 0.15.0",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crates-index"
+version = "0.18.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0044896374c388ccbf1497dad6384bf6111dbcad9d7069506df7450ce9b62ea3"
+dependencies = [
+ "git2",
+ "hex",
+ "home",
+ "memchr",
+ "num_cpus",
+ "rustc-hash",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "smartstring",
+]
+
+[[package]]
+name = "cross_installer"
+version = "0.1.0"
+dependencies = [
+ "clap",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6"
+dependencies = [
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+dependencies = [
+ "generic-array 0.14.5",
+ "typenum",
+]
+
+[[package]]
+name = "deunicode"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "850878694b7933ca4c9569d30a34b55031b9b139ee1fc7b94a527c4ef960d690"
+
+[[package]]
+name = "digest"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+dependencies = [
+ "generic-array 0.12.4",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
+dependencies = [
+ "block-buffer 0.10.2",
+ "crypto-common",
+]
+
+[[package]]
+name = "fake-simd"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+dependencies = [
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "fuchsia-cprng"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+
+[[package]]
+name = "generic-array"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "git2"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e7d3b96ec1fcaa8431cf04a4f1ef5caafe58d5cf7bcc31f09c1626adddb0ffe"
+dependencies = [
+ "bitflags",
+ "libc",
+ "libgit2-sys",
+ "log",
+ "url",
+]
+
+[[package]]
+name = "globset"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "fnv",
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "globwalk"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e3af942408868f6934a7b85134a3230832b9977cf66125df2f9edcfce4ddcc"
+dependencies = [
+ "bitflags",
+ "ignore",
+ "walkdir",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "home"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "humansize"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02296996cb8796d7c6e3bc2d9211b7802812d36999a51bb754123ead7d37d026"
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "ignore"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d"
+dependencies = [
+ "crossbeam-utils",
+ "globset",
+ "lazy_static",
+ "log",
+ "memchr",
+ "regex",
+ "same-file",
+ "thread_local",
+ "walkdir",
+ "winapi-util",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
+[[package]]
+name = "jobserver"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "libgit2-sys"
+version = "0.13.1+1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43e598aa7a4faedf1ea1b4608f582b06f0f40211eec551b7ef36019ae3f62def"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "pkg-config",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "maplit"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+
+[[package]]
+name = "matches"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "num"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e63899ad0da84ce718c14936262a41cee2c79c981fc0a0e7c7beb47d5a07e8c1"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "rand 0.4.6",
+ "rustc-serialize",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b288631d7878aaf59442cffd36910ea604ecd7745c36054328595114001c9656"
+dependencies = [
+ "num-traits",
+ "rustc-serialize",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "rustc-serialize",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "opaque-debug"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "parse-zoneinfo"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "pathdiff"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+
+[[package]]
+name = "percent-encoding"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "pest"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
+dependencies = [
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
+dependencies = [
+ "maplit",
+ "pest",
+ "sha-1",
+]
+
+[[package]]
+name = "phf"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+dependencies = [
+ "phf_shared",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+dependencies = [
+ "siphasher",
+ "uncased",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
+dependencies = [
+ "fuchsia-cprng",
+ "libc",
+ "rand_core 0.3.1",
+ "rdrand",
+ "winapi",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core 0.6.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+dependencies = [
+ "rand_core 0.4.2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rdrand"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+dependencies = [
+ "rand_core 0.3.1",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustc-serialize"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
+
+[[package]]
+name = "ryu"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a3381e03edd24287172047536f20cabde766e2cd3e65e6b00fb3af51c4f38d"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha-1"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
+dependencies = [
+ "block-buffer 0.7.3",
+ "digest 0.8.1",
+ "fake-simd",
+ "opaque-debug",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.3",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a86232ab60fa71287d7f2ddae4a7073f6b7aac33631c3015abb556f08c6d0a3e"
+
+[[package]]
+name = "slug"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3bc762e6a4b6c6fcaade73e77f9ebc6991b676f88bb2358bddb56560f073373"
+dependencies = [
+ "deunicode",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "smartstring"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea958ad90cacc8ece7f238fde3671e1b350ee1741964edf2a22fd16f60224163"
+dependencies = [
+ "serde",
+ "static_assertions",
+]
+
+[[package]]
+name = "smawk"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+
+[[package]]
+name = "spectral"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae3c15181f4b14e52eeaac3efaeec4d2764716ce9c86da0c934c3e318649c5ba"
+dependencies = [
+ "num",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "libc",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "tera"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3cac831b615c25bcef632d1cabf864fa05813baad3d526829db18eb70e8b58d"
+dependencies = [
+ "chrono",
+ "chrono-tz",
+ "globwalk",
+ "humansize",
+ "lazy_static",
+ "percent-encoding",
+ "pest",
+ "pest_derive",
+ "rand 0.8.5",
+ "regex",
+ "serde",
+ "serde_json",
+ "slug",
+ "unic-segment",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+dependencies = [
+ "smawk",
+ "unicode-linebreak",
+ "unicode-width",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "thread_local"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "toml"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
+
+[[package]]
+name = "uncased"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baeed7327e25054889b9bd4f975f32e5f4c5d434042d59ab6cd4142c0a76ed0"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-segment"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4ed5d26be57f84f176157270c112ef57b86debac9cd21daaabbe56db0f88f23"
+dependencies = [
+ "unic-ucd-segment",
+]
+
+[[package]]
+name = "unic-ucd-segment"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2079c122a62205b421f499da10f3ee0f7697f012f55b675e002483c73ea34700"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
+
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a52dcaab0c48d931f7cc8ef826fa51690a08e1ea55117ef26f89864f532383f"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "url"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "urls_generator"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "hex",
+ "serde_json",
+ "sha2",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "walkdir"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+dependencies = [
+ "same-file",
+ "winapi",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/crate_universe/Cargo.toml b/third_party/rules_rust/crate_universe/Cargo.toml
new file mode 100644
index 0000000..1fe8d83
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/Cargo.toml
@@ -0,0 +1,43 @@
+[workspace]
+members = [
+    "tools/cross_installer",
+    "tools/urls_generator",
+]
+
+[package]
+name = "cargo-bazel"
+version = "0.0.28"
+authors = [
+    "Andre Brisco - andre.brisco@protonmail.com",
+]
+edition = "2018"
+
+[features]
+cargo = []
+default = ["cargo"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.51"
+cargo_metadata = "0.14.1"
+cargo_toml = "0.11.4"
+cargo-lock = "7.0.1"
+cargo-platform = "0.1.2"
+cfg-expr = "0.10.1"
+clap = { version = "3.0.14", features = ["derive", "env"] }
+crates-index = { version = "0.18.5", default-features = false }
+hex = "0.4.3"
+pathdiff = "0.2.1"
+regex = "1.5.4"
+semver = "1.0.5"
+serde = "1.0.136"
+serde_json = "1.0.79"
+sha2 = "0.10.1"
+tempfile = "3.2.0"
+tera = "1.15.0"
+textwrap = "0.14.2"
+toml = "0.5.8"
+
+[dev-dependencies]
+spectral = "0.6.0"
diff --git a/third_party/rules_rust/crate_universe/README.md b/third_party/rules_rust/crate_universe/README.md
new file mode 100644
index 0000000..2654173
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/README.md
@@ -0,0 +1,11 @@
+# Cargo->Bazel
+
+`cargo->bazel` is a tool used which uses [Cargo][cargo] to generate build targets for [Bazel][bazel].
+
+## [Documentation][docs]
+
+For detailed documentation. See https://bazelbuild.github.io/rules_rust/crate_universe.html
+
+[cargo]: https://doc.rust-lang.org/cargo/
+[bazel]: https://bazel.build/
+[docs]: https://bazelbuild.github.io/rules_rust/crate_universe.html
diff --git a/third_party/rules_rust/crate_universe/crates.bzl b/third_party/rules_rust/crate_universe/crates.bzl
new file mode 100644
index 0000000..40dc413
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/crates.bzl
@@ -0,0 +1,68 @@
+"""A module defining dependencies of the `cargo-bazel` Rust target"""
+
+load("@rules_rust//rust:defs.bzl", "rust_common")
+load("//crate_universe:defs.bzl", "crate", "crates_repository", "crates_vendor")
+load("//crate_universe:deps_bootstrap.bzl", "cargo_bazel_bootstrap")
+load("//crate_universe/3rdparty:third_party_deps.bzl", "third_party_deps")
+load("//crate_universe/3rdparty/crates:crates.bzl", _vendor_crate_repositories = "crate_repositories")
+load("//crate_universe/private:vendor_utils.bzl", "crates_vendor_deps")
+load("//crate_universe/tools/cross_installer:cross_installer_deps.bzl", "cross_installer_deps")
+
+USE_CRATES_REPOSITORY = False
+
+_REPOSITORY_NAME = "crate_index"
+
+_ANNOTATIONS = {
+    "libgit2-sys": [crate.annotation(
+        gen_build_script = False,
+        deps = ["@libgit2"],
+    )],
+    "libz-sys": [crate.annotation(
+        gen_build_script = False,
+        deps = ["@zlib"],
+    )],
+}
+
+_MANIFESTS = [
+    "@rules_rust//crate_universe:Cargo.toml",
+    "@rules_rust//crate_universe/tools/cross_installer:Cargo.toml",
+    "@rules_rust//crate_universe/tools/urls_generator:Cargo.toml",
+]
+
+def crate_deps_repository(rust_version = rust_common.default_version, bootstrap = False):
+    """Define dependencies of the `cargo-bazel` Rust target
+
+    Args:
+        rust_version (str, optional): The version of rust to use when generating dependencies.
+        bootstrap (bool, optional): If true, a `cargo_bootstrap_repository` target will be generated.
+    """
+    third_party_deps()
+
+    cargo_bazel_bootstrap(rust_version = rust_version)
+
+    if USE_CRATES_REPOSITORY:
+        crates_repository(
+            name = _REPOSITORY_NAME,
+            annotations = _ANNOTATIONS,
+            generator = "@cargo_bazel_bootstrap//:cargo-bazel" if bootstrap else None,
+            lockfile = "@rules_rust//crate_universe:Cargo.Bazel.lock",
+            manifests = _MANIFESTS,
+            rust_version = rust_version,
+        )
+
+    else:
+        _vendor_crate_repositories()
+
+    crates_vendor_deps()
+    cross_installer_deps()
+
+def crate_deps_target(name = "crates_vendor", vendor_path = "crates"):
+    crates_vendor(
+        name = name,
+        repository_name = _REPOSITORY_NAME,
+        annotations = _ANNOTATIONS,
+        manifests = _MANIFESTS,
+        vendor_path = vendor_path,
+        mode = "remote",
+        tags = ["manual"],
+    )
diff --git a/third_party/rules_rust/crate_universe/crates_deps.bzl b/third_party/rules_rust/crate_universe/crates_deps.bzl
new file mode 100644
index 0000000..5883d50
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/crates_deps.bzl
@@ -0,0 +1,8 @@
+"""Transitive dependencies of the `cargo-bazel` Rust target"""
+
+load("@crate_index//:defs.bzl", _repository_crate_repositories = "crate_repositories")
+load("//crate_universe:crates.bzl", "USE_CRATES_REPOSITORY")
+
+def crate_repositories():
+    if USE_CRATES_REPOSITORY:
+        _repository_crate_repositories()
diff --git a/third_party/rules_rust/crate_universe/defs.bzl b/third_party/rules_rust/crate_universe/defs.bzl
new file mode 100644
index 0000000..13060e8
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/defs.bzl
@@ -0,0 +1,172 @@
+"""# Crate Universe
+
+Crate Universe is a set of Bazel rule for generating Rust targets using Cargo.
+
+## Experimental
+
+`crate_universe` is experimental, and may have breaking API changes at any time. These instructions may also change without notice.
+
+## Rules
+
+- [crates_repository](#crates_repository)
+- [crates_vendor](#crates_vendor)
+- [crate.spec](#cratespec)
+- [crate.workspace_member](#crateworkspace_member)
+- [crate.annotation](#crateannotation)
+- [render_config](#render_config)
+- [splicing_config](#splicing_config)
+
+## `crates_repository` Workflows
+
+The [`crates_repository`](#crates_repository) rule (the primary repository rule of `cargo-bazel`) supports a number of different ways users
+can express and organize their dependencies. The most common are listed below though there are more to be found in
+the [./examples/crate_universe](https://github.com/bazelbuild/rules_rust/tree/main/examples/crate_universe) directory.
+
+### Cargo Workspaces
+
+One of the simpler ways to wire up dependencies would be to first structure your project into a [Cargo workspace][cw].
+The `crates_repository` rule can ingest a the root `Cargo.toml` file and generate dependencies from there.
+
+```python
+load("@rules_rust//crate_universe:defs.bzl", "crate", "crates_repository")
+
+crates_repository(
+    name = "crate_index",
+    lockfile = "//:Cargo.Bazel.lock",
+    manifests = ["//:Cargo.toml"],
+)
+
+load("@crate_index//:defs.bzl", "crate_repositories")
+
+crate_repositories()
+```
+
+The generated `crates_repository` contains helper macros which make collecting dependencies for Bazel targets simpler.
+Notably, the `all_crate_deps` and `aliases` macros commonly allow the `Cargo.toml` files to be the single source of
+truth for dependencies. Since these macros come from the generated repository, the dependencies and alias definitions
+they return will automatically update BUILD targets.
+
+```python
+load("@crate_index//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "lib",
+    aliases = aliases(),
+    deps = all_crate_deps(
+        normal = True,
+    ),
+    proc_macro_deps = all_crate_deps(
+        proc_macro = True,
+    ),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":lib",
+    aliases = aliases(
+        normal_dev = True,
+        proc_macro_dev = True,
+    ),
+    deps = all_crate_deps(
+        normal_dev = True,
+    ),
+    proc_macro_deps = all_crate_deps(
+        proc_macro_dev = True,
+    ),
+)
+```
+
+### Direct Packages
+
+In cases where Rust targets have heavy interractions with other Bazel targests ([Cc][cc], [Proto][proto], etc.),
+maintaining `Cargo.toml` files may have deminishing returns as things like [rust-analyzer][ra] begin to be confused
+about missing targets or environment variables defined only in Bazel. In workspaces like this, it may be desirable
+to have a "Cargo free" setup. `crates_repository` supports this through the `packages` attribute.
+
+```python
+load("@cargo_bazel//:defs.bzl", "crate", "crates_repository", "render_config")
+
+crates_repository(
+    name = "crate_index",
+    lockfile = "//:Cargo.Bazel.lock",
+    packages = {
+        "async-trait": crate.spec(
+            version = "0.1.51",
+        ),
+        "mockall": crate.spec(
+            version = "0.10.2",
+        ),
+        "tokio": crate.spec(
+            version = "1.12.0",
+        ),
+    },
+    # Setting the default package name to `""` forces the use of the macros defined in this repository
+    # to always use the root package when looking for dependencies or aliases. This should be considered
+    # optional as the repository also exposes alises for easy access to all dependencies.
+    render_config = render_config(
+        default_package_name = ""
+    ),
+)
+
+load("@crate_index//:defs.bzl", "crate_repositories")
+
+crate_repositories()
+```
+
+Consuming dependencies may be more ergonomic in this case through the aliases defined in the new repository.
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "lib",
+    deps = [
+        "@crate_index//:tokio",
+    ],
+    proc_macro_deps = [
+        "@crate_index//:async-trait",
+    ],
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":lib",
+    deps = [
+        "@crate_index//:mockall",
+    ],
+)
+```
+
+[cw]: https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html
+[cc]: https://docs.bazel.build/versions/main/be/c-cpp.html
+[proto]: https://rules-proto-grpc.com/en/latest/lang/rust.html
+[ra]: https://rust-analyzer.github.io/
+"""
+
+load(
+    "//crate_universe/private:crate.bzl",
+    _crate = "crate",
+)
+load(
+    "//crate_universe/private:crates_repository.bzl",
+    _crates_repository = "crates_repository",
+)
+load(
+    "//crate_universe/private:crates_vendor.bzl",
+    _crates_vendor = "crates_vendor",
+)
+load(
+    "//crate_universe/private:generate_utils.bzl",
+    _render_config = "render_config",
+)
+load(
+    "//crate_universe/private:splicing_utils.bzl",
+    _splicing_config = "splicing_config",
+)
+
+crate = _crate
+crates_repository = _crates_repository
+crates_vendor = _crates_vendor
+render_config = _render_config
+splicing_config = _splicing_config
diff --git a/third_party/rules_rust/crate_universe/deps_bootstrap.bzl b/third_party/rules_rust/crate_universe/deps_bootstrap.bzl
new file mode 100644
index 0000000..28f6d14
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/deps_bootstrap.bzl
@@ -0,0 +1,25 @@
+"""A module is used to assist in bootstrapping cargo-bazel"""
+
+load("//cargo:defs.bzl", "cargo_bootstrap_repository")
+load("//crate_universe/private:srcs.bzl", "CARGO_BAZEL_SRCS")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:common.bzl", "rust_common")
+
+def cargo_bazel_bootstrap(name = "cargo_bazel_bootstrap", rust_version = rust_common.default_version):
+    """An optional repository which bootstraps `cargo-bazel` for use with `crates_repository`
+
+    Args:
+        name (str, optional): The name of the `cargo_bootstrap_repository`.
+        rust_version (str, optional): The rust version to use. Defaults to the default of `cargo_bootstrap_repository`.
+    """
+    cargo_bootstrap_repository(
+        name = name,
+        srcs = CARGO_BAZEL_SRCS,
+        binary = "cargo-bazel",
+        cargo_lockfile = "@rules_rust//crate_universe:Cargo.lock",
+        cargo_toml = "@rules_rust//crate_universe:Cargo.toml",
+        version = rust_version,
+        # The increased timeout helps avoid flakes in CI
+        timeout = 900,
+    )
diff --git a/third_party/rules_rust/crate_universe/private/BUILD.bazel b/third_party/rules_rust/crate_universe/private/BUILD.bazel
new file mode 100644
index 0000000..39f0969
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/BUILD.bazel
@@ -0,0 +1,24 @@
+load(":bootstrap_utils.bzl", "srcs_module")
+
+package(default_visibility = ["//:__subpackages__"])
+
+exports_files(glob(["**"]))
+
+srcs_module(
+    name = "srcs_module",
+    srcs = "//crate_universe:rust_srcs",
+    dest = ":srcs.bzl",
+)
+
+filegroup(
+    name = "bzl_srcs",
+    srcs = glob(["*.bzl"]),
+)
+
+filegroup(
+    name = "distro",
+    srcs = glob(["*.bzl"]) + [
+        "BUILD.bazel",
+        "//crate_universe/private/vendor:distro",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/private/bootstrap_utils.bzl b/third_party/rules_rust/crate_universe/private/bootstrap_utils.bzl
new file mode 100644
index 0000000..9df387e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/bootstrap_utils.bzl
@@ -0,0 +1,106 @@
+"""Utilities directly related to bootstrapping `cargo-bazel`"""
+
+_SRCS_TEMPLATE = """\
+\"\"\"A generate file containing all source files used to produce `cargo-bazel`\"\"\"
+
+# Each source file is tracked as a target so the `cargo_bootstrap_repository`
+# rule will know to automatically rebuild if any of the sources changed.
+CARGO_BAZEL_SRCS = [
+    {srcs}
+]
+"""
+
+def _srcs_module_impl(ctx):
+    srcs = ["@rules_rust{}".format(src.owner) for src in ctx.files.srcs]
+    if not srcs:
+        fail("`srcs` cannot be empty")
+    output = ctx.actions.declare_file(ctx.label.name)
+
+    ctx.actions.write(
+        output = output,
+        content = _SRCS_TEMPLATE.format(
+            srcs = "\n    ".join(["\"{}\",".format(src) for src in srcs]),
+        ),
+    )
+
+    return DefaultInfo(
+        files = depset([output]),
+    )
+
+_srcs_module = rule(
+    doc = "A rule for writing a list of sources to a templated file",
+    implementation = _srcs_module_impl,
+    attrs = {
+        "srcs": attr.label(
+            doc = "A filegroup of source files",
+            allow_files = True,
+        ),
+    },
+)
+
+_INSTALLER_TEMPLATE = """\
+#!/bin/bash
+set -euo pipefail
+cp -f "{path}" "${{BUILD_WORKSPACE_DIRECTORY}}/{dest}"
+"""
+
+def _srcs_installer_impl(ctx):
+    output = ctx.actions.declare_file(ctx.label.name + ".sh")
+    target_file = ctx.file.input
+    dest = ctx.file.dest.short_path
+
+    ctx.actions.write(
+        output = output,
+        content = _INSTALLER_TEMPLATE.format(
+            path = target_file.short_path,
+            dest = dest,
+        ),
+        is_executable = True,
+    )
+
+    return DefaultInfo(
+        files = depset([output]),
+        runfiles = ctx.runfiles(files = [target_file]),
+        executable = output,
+    )
+
+_srcs_installer = rule(
+    doc = "A rule for writing a file back to the repository",
+    implementation = _srcs_installer_impl,
+    attrs = {
+        "dest": attr.label(
+            doc = "the file name to use for installation",
+            allow_single_file = True,
+            mandatory = True,
+        ),
+        "input": attr.label(
+            doc = "The file to write back to the repository",
+            allow_single_file = True,
+            mandatory = True,
+        ),
+    },
+    executable = True,
+)
+
+def srcs_module(name, dest, **kwargs):
+    """A helper rule to ensure the bootstrapping functionality of `cargo-bazel` is always up to date
+
+    Args:
+        name (str): The name of the sources module
+        dest (str): The filename the module should be written as in the current package.
+        **kwargs (dict): Additional keyword arguments
+    """
+    tags = kwargs.pop("tags", [])
+
+    _srcs_module(
+        name = name,
+        tags = tags,
+        **kwargs
+    )
+
+    _srcs_installer(
+        name = name + ".install",
+        input = name,
+        dest = dest,
+        tags = tags,
+    )
diff --git a/third_party/rules_rust/crate_universe/private/common_utils.bzl b/third_party/rules_rust/crate_universe/private/common_utils.bzl
new file mode 100644
index 0000000..ae65b63
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/common_utils.bzl
@@ -0,0 +1,109 @@
+"""Common utilities useful for unifying the behavior of different parts of `cargo-bazel`."""
+
+# buildifier: disable=bzl-visibility
+load(
+    "//cargo/private:cargo_utils.bzl",
+    _get_host_triple = "get_host_triple",
+    _rust_get_rust_tools = "get_rust_tools",
+)
+
+get_host_triple = _get_host_triple
+
+CARGO_BAZEL_ISOLATED = "CARGO_BAZEL_ISOLATED"
+
+_EXECUTE_ERROR_MESSAGE = """\
+Command {args} failed with exit code {exit_code}.
+STDOUT ------------------------------------------------------------------------
+{stdout}
+STDERR ------------------------------------------------------------------------
+{stderr}
+"""
+
+def execute(repository_ctx, args, env = {}):
+    """A heler macro for executing some arguments and displaying nicely formatted errors
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        args (list): A list of strings which act as `argv` for execution.
+        env (dict, optional): Environment variables to set in the execution environment.
+
+    Returns:
+        struct: The results of `repository_ctx.execute`
+    """
+    result = repository_ctx.execute(
+        args,
+        environment = env,
+        quiet = repository_ctx.attr.quiet,
+    )
+
+    if result.return_code:
+        fail(_EXECUTE_ERROR_MESSAGE.format(
+            args = args,
+            exit_code = result.return_code,
+            stdout = result.stdout,
+            stderr = result.stderr,
+        ))
+
+    return result
+
+def get_rust_tools(repository_ctx, host_triple):
+    """Retrieve a cargo and rustc binary based on the host triple.
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        host_triple (struct): A `@rules_rust//rust:triple.bzl%triple` object.
+
+    Returns:
+        struct: A struct containing the expected rust tools
+    """
+
+    # This is a bit hidden but to ensure Cargo behaves consistently based
+    # on the user provided config file, the config file is installed into
+    # the `CARGO_HOME` path. This is done so here since fetching tools
+    # is expected to always occur before any subcommands are run.
+    if repository_ctx.attr.isolated and repository_ctx.attr.cargo_config:
+        cargo_home = _cargo_home_path(repository_ctx)
+        cargo_home_config = repository_ctx.path("{}/config.toml".format(cargo_home))
+        cargo_config = repository_ctx.path(repository_ctx.attr.cargo_config)
+        repository_ctx.symlink(cargo_config, cargo_home_config)
+
+    return _rust_get_rust_tools(
+        cargo_template = repository_ctx.attr.rust_toolchain_cargo_template,
+        rustc_template = repository_ctx.attr.rust_toolchain_rustc_template,
+        host_triple = host_triple,
+        version = repository_ctx.attr.rust_version,
+    )
+
+def _cargo_home_path(repository_ctx):
+    """Define a path within the repository to use in place of `CARGO_HOME`
+
+    Args:
+        repository_ctx (repository_ctx): The rules context object
+
+    Returns:
+        path: The path to a directory to use as `CARGO_HOME`
+    """
+    return repository_ctx.path(".cargo_home")
+
+def cargo_environ(repository_ctx):
+    """Define Cargo environment varables for use with `cargo-bazel`
+
+    Args:
+        repository_ctx (repository_ctx): The rules context object
+
+    Returns:
+        dict: A set of environment variables for `cargo-bazel` executions
+    """
+    env = dict()
+
+    if CARGO_BAZEL_ISOLATED in repository_ctx.os.environ:
+        if repository_ctx.os.environ[CARGO_BAZEL_ISOLATED].lower() in ["true", "1", "yes", "on"]:
+            env.update({
+                "CARGO_HOME": str(_cargo_home_path(repository_ctx)),
+            })
+    elif repository_ctx.attr.isolated:
+        env.update({
+            "CARGO_HOME": str(_cargo_home_path(repository_ctx)),
+        })
+
+    return env
diff --git a/third_party/rules_rust/crate_universe/private/crate.bzl b/third_party/rules_rust/crate_universe/private/crate.bzl
new file mode 100644
index 0000000..611bf62
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/crate.bzl
@@ -0,0 +1,172 @@
+"""Macros used for represeting crates or annotations for existing crates"""
+
+def _workspace_member(version, sha256 = None):
+    """Define information for extra workspace members
+
+    Args:
+        version (str): The semver of the crate to download. Must be an exact version.
+        sha256 (str, optional): The sha256 checksum of the `.crate` file.
+
+    Returns:
+        string: A json encoded string of all inputs
+    """
+    return json.encode(struct(
+        version = version,
+        sha256 = sha256,
+    ))
+
+def _spec(
+        package = None,
+        version = None,
+        default_features = True,
+        features = [],
+        git = None,
+        rev = None):
+    """A constructor for a crate dependency.
+
+    See [specifying dependencies][sd] in the Cargo book for more details.
+
+    [sd]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+
+    Args:
+        package (str, optional): The explicit name of the package (used when attempting to alias a crate).
+        version (str, optional): The exact version of the crate. Cannot be used with `git`.
+        default_features (bool, optional): Maps to the `default-features` flag.
+        features (list, optional): A list of features to use for the crate
+        git (str, optional): The Git url to use for the crate. Cannot be used with `version`.
+        rev (str, optional): The git revision of the remote crate. Tied with the `git` param.
+
+    Returns:
+        string: A json encoded string of all inputs
+    """
+    return json.encode(struct(
+        package = package,
+        default_features = default_features,
+        features = features,
+        version = version,
+        git = git,
+        rev = rev,
+    ))
+
+def _assert_absolute(label):
+    """Ensure a given label is an absolute label
+
+    Args:
+        label (Label): The label to check
+    """
+    label_str = str(label)
+    if not label.startswith("@"):
+        fail("The labels must be absolute. Please update '{}'".format(
+            label_str,
+        ))
+
+def _annotation(
+        version = "*",
+        additive_build_file = None,
+        additive_build_file_content = None,
+        build_script_data = None,
+        build_script_data_glob = None,
+        build_script_deps = None,
+        build_script_env = None,
+        build_script_proc_macro_deps = None,
+        build_script_rustc_env = None,
+        compile_data = None,
+        compile_data_glob = None,
+        crate_features = None,
+        data = None,
+        data_glob = None,
+        deps = None,
+        gen_build_script = None,
+        patch_args = None,
+        patch_tool = None,
+        patches = None,
+        proc_macro_deps = None,
+        rustc_env = None,
+        rustc_env_files = None,
+        rustc_flags = None,
+        shallow_since = None):
+    """A collection of extra attributes and settings for a particular crate
+
+    Args:
+        version (str, optional): The version or semver-conditions to match with a crate.
+        additive_build_file_content (str, optional): Extra contents to write to the bottom of generated BUILD files.
+        additive_build_file (str, optional): A file containing extra contents to write to the bottom of
+            generated BUILD files.
+        build_script_data (list, optional): A list of labels to add to a crate's `cargo_build_script::data` attribute.
+        build_script_data_glob (list, optional): A list of glob patterns to add to a crate's `cargo_build_script::data`
+            attribute.
+        build_script_deps (list, optional): A list of labels to add to a crate's `cargo_build_script::deps` attribute.
+        build_script_env (dict, optional): Additional environment variables to set on a crate's
+            `cargo_build_script::env` attribute.
+        build_script_proc_macro_deps (list, optional): A list of labels to add to a crate's
+            `cargo_build_script::proc_macro_deps` attribute.
+        build_script_rustc_env (dict, optional): Additional environment variables to set on a crate's
+            `cargo_build_script::env` attribute.
+        compile_data (list, optional): A list of labels to add to a crate's `rust_library::compile_data` attribute.
+        compile_data_glob (list, optional): A list of glob patterns to add to a crate's `rust_library::compile_data`
+            attribute.
+        crate_features (list, optional): A list of strings to add to a crate's `rust_library::crate_features`
+            attribute.
+        data (list, optional): A list of labels to add to a crate's `rust_library::data` attribute.
+        data_glob (list, optional): A list of glob patterns to add to a crate's `rust_library::data` attribute.
+        deps (list, optional): A list of labels to add to a crate's `rust_library::deps` attribute.
+        gen_build_script (bool, optional): An authorative flag to determine whether or not to produce
+            `cargo_build_script` targets for the current crate.
+        patch_args (list, optional): The `patch_args` attribute of a Bazel repository rule. See
+            [http_archive.patch_args](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_args)
+        patch_tool (list, optional): The `patch_tool` attribute of a Bazel repository rule. See
+            [http_archive.patch_tool](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_tool)
+        patches (list, optional): The `patches` attribute of a Bazel repository rule. See
+            [http_archive.patches](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patches)
+        proc_macro_deps (list, optional): A list of labels to add to a crate's `rust_library::proc_macro_deps`
+            attribute.
+        rustc_env (dict, optional): Additional variables to set on a crate's `rust_library::rustc_env` attribute.
+        rustc_env_files (list, optional): A list of labels to set on a crate's `rust_library::rustc_env_files`
+            attribute.
+        rustc_flags (list, optional): A list of strings to set on a crate's `rust_library::rustc_flags` attribute.
+        shallow_since (str, optional): An optional timestamp used for crates originating from a git repository
+            instead of a crate registry. This flag optimizes fetching the source code.
+
+    Returns:
+        string: A json encoded string containing the specified version and separately all other inputs.
+    """
+    if additive_build_file:
+        _assert_absolute(additive_build_file)
+    if patches:
+        for patch in patches:
+            _assert_absolute(patch)
+
+    return json.encode((
+        version,
+        struct(
+            additive_build_file = additive_build_file,
+            additive_build_file_content = additive_build_file_content,
+            build_script_data = build_script_data,
+            build_script_data_glob = build_script_data_glob,
+            build_script_deps = build_script_deps,
+            build_script_env = build_script_env,
+            build_script_proc_macro_deps = build_script_proc_macro_deps,
+            build_script_rustc_env = build_script_rustc_env,
+            compile_data = compile_data,
+            compile_data_glob = compile_data_glob,
+            crate_features = crate_features,
+            data = data,
+            data_glob = data_glob,
+            deps = deps,
+            gen_build_script = gen_build_script,
+            patch_args = patch_args,
+            patch_tool = patch_tool,
+            patches = patches,
+            proc_macro_deps = proc_macro_deps,
+            rustc_env = rustc_env,
+            rustc_env_files = rustc_env_files,
+            rustc_flags = rustc_flags,
+            shallow_since = shallow_since,
+        ),
+    ))
+
+crate = struct(
+    spec = _spec,
+    annotation = _annotation,
+    workspace_member = _workspace_member,
+)
diff --git a/third_party/rules_rust/crate_universe/private/crates_repository.bzl b/third_party/rules_rust/crate_universe/private/crates_repository.bzl
new file mode 100644
index 0000000..92def09
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/crates_repository.bzl
@@ -0,0 +1,244 @@
+"""`crates_repository` rule implementation"""
+
+load("//crate_universe/private:common_utils.bzl", "get_host_triple", "get_rust_tools")
+load(
+    "//crate_universe/private:generate_utils.bzl",
+    "CRATES_REPOSITORY_ENVIRON",
+    "determine_repin",
+    "execute_generator",
+    "generate_config",
+    "get_generator",
+    "get_lockfile",
+)
+load(
+    "//crate_universe/private:splicing_utils.bzl",
+    "create_splicing_manifest",
+    "splice_workspace_manifest",
+)
+load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_SHA256S", "CARGO_BAZEL_URLS")
+load("//rust:defs.bzl", "rust_common")
+load("//rust/platform:triple_mappings.bzl", "SUPPORTED_PLATFORM_TRIPLES")
+
+def _crates_repository_impl(repository_ctx):
+    # Determine the current host's platform triple
+    host_triple = get_host_triple(repository_ctx)
+
+    # Locate the generator to use
+    generator, generator_sha256 = get_generator(repository_ctx, host_triple.triple)
+
+    # Generate a config file for all settings
+    config = generate_config(repository_ctx)
+
+    # Locate the lockfile
+    lockfile = get_lockfile(repository_ctx)
+
+    # Locate Rust tools (cargo, rustc)
+    tools = get_rust_tools(repository_ctx, host_triple)
+    cargo_path = repository_ctx.path(tools.cargo)
+    rustc_path = repository_ctx.path(tools.rustc)
+
+    # Create a manifest of all dependency inputs
+    splicing_manifest = create_splicing_manifest(repository_ctx)
+
+    # Determine whether or not to repin depednencies
+    repin = determine_repin(
+        repository_ctx = repository_ctx,
+        generator = generator,
+        lockfile_path = lockfile.path,
+        lockfile_kind = lockfile.kind,
+        config = config.path,
+        splicing_manifest = splicing_manifest,
+        cargo = cargo_path,
+        rustc = rustc_path,
+    )
+
+    # If re-pinning is enabled, gather additional inputs for the generator
+    kwargs = dict()
+    if repin or lockfile.kind == "cargo":
+        # Generate a top level Cargo workspace and manifest for use in generation
+        metadata_path = splice_workspace_manifest(
+            repository_ctx = repository_ctx,
+            generator = generator,
+            lockfile = lockfile,
+            splicing_manifest = splicing_manifest,
+            cargo = cargo_path,
+            rustc = rustc_path,
+        )
+
+        kwargs.update({
+            "metadata": metadata_path,
+            "repin": True,
+        })
+
+    # Run the generator
+    execute_generator(
+        repository_ctx = repository_ctx,
+        generator = generator,
+        config = config.path,
+        splicing_manifest = splicing_manifest,
+        lockfile_path = lockfile.path,
+        lockfile_kind = lockfile.kind,
+        repository_dir = repository_ctx.path("."),
+        cargo = cargo_path,
+        rustc = rustc_path,
+        # sysroot = tools.sysroot,
+        **kwargs
+    )
+
+    # Determine the set of reproducible values
+    attrs = {attr: getattr(repository_ctx.attr, attr) for attr in dir(repository_ctx.attr)}
+    exclude = ["to_json", "to_proto"]
+    for attr in exclude:
+        attrs.pop(attr, None)
+
+    # Note that this is only scoped to the current host platform. Users should
+    # ensure they provide all the values necessary for the host environments
+    # they support
+    if generator_sha256:
+        attrs.update({"generator_sha256s": generator_sha256})
+
+    return attrs
+
+crates_repository = repository_rule(
+    doc = """\
+A rule for defining and downloading Rust dependencies (crates).
+
+Environment Variables:
+
+| variable | usage |
+| --- | --- |
+| `CARGO_BAZEL_GENERATOR_SHA256` | The sha256 checksum of the file located at `CARGO_BAZEL_GENERATOR_URL` |
+| `CARGO_BAZEL_GENERATOR_URL` | The URL of a cargo-bazel binary. This variable takes precedence over attributes and can use `file://` for local paths |
+| `CARGO_BAZEL_ISOLATED` | An authorative flag as to whether or not the `CARGO_HOME` environment variable should be isolated from the host configuration |
+| `CARGO_BAZEL_REPIN` | An indicator that the dependencies represented by the rule should be regenerated. `REPIN` may also be used. |
+
+""",
+    implementation = _crates_repository_impl,
+    attrs = {
+        "annotations": attr.string_list_dict(
+            doc = "Extra settings to apply to crates. See [crate.annotations](#crateannotations).",
+        ),
+        "cargo_config": attr.label(
+            doc = "A [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html) file",
+        ),
+        "extra_workspace_member_url_template": attr.string(
+            doc = "The registry url to use when fetching extra workspace members",
+            default = "https://crates.io/api/v1/crates/{name}/{version}/download",
+        ),
+        "extra_workspace_members": attr.string_dict(
+            doc = (
+                "Additional crates to download and include as a workspace member. This is unfortunately required in " +
+                "order to add information about \"binary-only\" crates so that a `rust_binary` may be generated for " +
+                "it. [rust-lang/cargo#9096](https://github.com/rust-lang/cargo/issues/9096) tracks an RFC which may " +
+                "solve for this."
+            ),
+        ),
+        "generate_build_scripts": attr.bool(
+            doc = (
+                "Whether or not to generate " +
+                "[cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default."
+            ),
+            default = True,
+        ),
+        "generator": attr.string(
+            doc = (
+                "The absolute label of a generator. Eg. `@cargo_bazel_bootstrap//:cargo-bazel`. " +
+                "This is typically used when bootstrapping"
+            ),
+        ),
+        "generator_sha256s": attr.string_dict(
+            doc = "Dictionary of `host_triple` -> `sha256` for a `cargo-bazel` binary.",
+            default = CARGO_BAZEL_SHA256S,
+        ),
+        "generator_urls": attr.string_dict(
+            doc = (
+                "URL template from which to download the `cargo-bazel` binary. `{host_triple}` and will be " +
+                "filled in according to the host platform."
+            ),
+            default = CARGO_BAZEL_URLS,
+        ),
+        "isolated": attr.bool(
+            doc = (
+                "If true, `CARGO_HOME` will be overwritten to a directory within the generated repository in " +
+                "order to prevent other uses of Cargo from impacting having any effect on the generated targets " +
+                "produced by this rule. For users who either have multiple `crate_repository` definitions in a " +
+                "WORKSPACE or rapidly re-pin dependencies, setting this to false may improve build times. This " +
+                "variable is also controled by `CARGO_BAZEL_ISOLATED` environment variable."
+            ),
+            default = True,
+        ),
+        "lockfile": attr.label(
+            doc = (
+                "The path to a file to use for reproducible renderings. Two kinds of lock files are supported, " +
+                "Cargo (`Cargo.lock` files) and Bazel (custom files generated by this rule, naming is irrelevant). " +
+                "Bazel lockfiles should be the prefered kind as they're desigend with Bazel's notions of " +
+                "reporducibility in mind. Cargo lockfiles can be used in cases where it's intended to be the " +
+                "source of truth, but more work will need to be done to generate BUILD files which are not " +
+                "guaranteed to be determinsitic."
+            ),
+            mandatory = True,
+        ),
+        "lockfile_kind": attr.string(
+            doc = (
+                "Two different kinds of lockfiles are supported, the custom \"Bazel\" lockfile, which is generated " +
+                "by this rule, and Cargo lockfiles (`Cargo.lock`). This attribute allows for explicitly defining " +
+                "the type in cases where it may not be auto-detectable."
+            ),
+            values = [
+                "auto",
+                "bazel",
+                "cargo",
+            ],
+            default = "auto",
+        ),
+        "manifests": attr.label_list(
+            doc = "A list of Cargo manifests (`Cargo.toml` files).",
+        ),
+        "packages": attr.string_dict(
+            doc = "A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).",
+        ),
+        "quiet": attr.bool(
+            doc = "If stdout and stderr should not be printed to the terminal.",
+            default = True,
+        ),
+        "render_config": attr.string(
+            doc = (
+                "The configuration flags to use for rendering. Use `//crate_universe:defs.bzl\\%render_config` to " +
+                "generate the value for this field. If unset, the defaults defined there will be used."
+            ),
+        ),
+        "rust_toolchain_cargo_template": attr.string(
+            doc = (
+                "The template to use for finding the host `cargo` binary. `{version}` (eg. '1.53.0'), " +
+                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
+                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), and `{tool}` (eg. 'rustc.exe') will be replaced in " +
+                "the string if present."
+            ),
+            default = "@rust_{system}_{arch}//:bin/{tool}",
+        ),
+        "rust_toolchain_rustc_template": attr.string(
+            doc = (
+                "The template to use for finding the host `rustc` binary. `{version}` (eg. '1.53.0'), " +
+                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
+                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), and `{tool}` (eg. 'cargo.exe') will be replaced in " +
+                "the string if present."
+            ),
+            default = "@rust_{system}_{arch}//:bin/{tool}",
+        ),
+        "rust_version": attr.string(
+            doc = "The version of Rust the currently registered toolchain is using. Eg. `1.56.0`, or `nightly-2021-09-08`",
+            default = rust_common.default_version,
+        ),
+        "splicing_config": attr.string(
+            doc = (
+                "The configuration flags to use for splicing Cargo maniests. Use `//crate_universe:defs.bzl\\%rsplicing_config` to " +
+                "generate the value for this field. If unset, the defaults defined there will be used."
+            ),
+        ),
+        "supported_platform_triples": attr.string_list(
+            doc = "A set of all platform triples to consider when generating dependencies.",
+            default = SUPPORTED_PLATFORM_TRIPLES,
+        ),
+    },
+    environ = CRATES_REPOSITORY_ENVIRON,
+)
diff --git a/third_party/rules_rust/crate_universe/private/crates_vendor.bzl b/third_party/rules_rust/crate_universe/private/crates_vendor.bzl
new file mode 100644
index 0000000..11cfaa1
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/crates_vendor.bzl
@@ -0,0 +1,335 @@
+"""Rules for vendoring Bazel targets into existing workspaces"""
+
+load("//crate_universe/private:generate_utils.bzl", "collect_crate_annotations", "render_config")
+load("//crate_universe/private:splicing_utils.bzl", "kebab_case_keys", "splicing_config")
+load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_LABEL")
+load("//rust/platform:triple_mappings.bzl", "SUPPORTED_PLATFORM_TRIPLES")
+
+_UNIX_WRAPPER = """\
+#!/usr/bin/env bash
+set -euo pipefail
+export RUNTIME_PWD="$(pwd)"
+eval exec env - BUILD_WORKSPACE_DIRECTORY="${{BUILD_WORKSPACE_DIRECTORY}}" {env} \\
+"{bin}" {args} "$@"
+"""
+
+_WINDOWS_WRAPPER = """\
+@ECHO OFF
+set RUNTIME_PWD=%CD%
+{env}
+
+call {bin} {args} %@%
+"""
+
+CARGO_BAZEL_GENERATOR_PATH = "CARGO_BAZEL_GENERATOR_PATH"
+
+def _runfiles_path(path, is_windows):
+    if is_windows:
+        runtime_pwd_var = "%RUNTIME_PWD%"
+    else:
+        runtime_pwd_var = "${RUNTIME_PWD}"
+    if path.startswith("../"):
+        return "{}/external/{}".format(runtime_pwd_var, path[len("../"):])
+    return "{}/{}".format(runtime_pwd_var, path)
+
+def _is_windows(ctx):
+    toolchain = ctx.toolchains[Label("@rules_rust//rust:toolchain")]
+    return "windows" in toolchain.target_triple
+
+def _get_output_package(ctx):
+    # Determine output directory
+    if ctx.attr.vendor_path.startswith("/"):
+        output = ctx.attr.vendor_path
+    else:
+        output = "{}/{}".format(
+            ctx.label.package,
+            ctx.attr.vendor_path,
+        )
+    return output
+
+def _write_data_file(ctx, name, data):
+    file = ctx.actions.declare_file("{}.{}".format(ctx.label.name, name))
+    ctx.actions.write(
+        output = file,
+        content = data,
+    )
+    return file
+
+def _write_splicing_manifest(ctx):
+    # Deserialize information about direct packges
+    direct_packages_info = {
+        # Ensure the data is using kebab-case as that's what `cargo_toml::DependencyDetail` expects.
+        pkg: kebab_case_keys(dict(json.decode(data)))
+        for (pkg, data) in ctx.attr.packages.items()
+    }
+
+    # Manifests are required to be single files
+    manifests = {m[DefaultInfo].files.to_list()[0].short_path: str(m.label) for m in ctx.attr.manifests}
+
+    config = json.decode(ctx.attr.splicing_config or splicing_config())
+    splicing_manifest_content = {
+        # TODO: How do cargo config files get factored into vendored builds
+        "cargo_config": None,
+        "direct_packages": direct_packages_info,
+        "manifests": manifests,
+    }
+
+    manifest = _write_data_file(
+        ctx = ctx,
+        name = "cargo-bazel-splicing-manifest.json",
+        data = json.encode_indent(
+            dict(dict(config).items() + splicing_manifest_content.items()),
+            indent = " " * 4,
+        ),
+    )
+
+    is_windows = _is_windows(ctx)
+
+    args = ["--splicing-manifest", _runfiles_path(manifest.short_path, is_windows)]
+    runfiles = [manifest]
+    return args, runfiles
+
+def _write_extra_manifests_manifest(ctx):
+    manifest = _write_data_file(
+        ctx = ctx,
+        name = "cargo-bazel-extra-manifests-manifest.json",
+        data = json.encode(struct(
+            # TODO: This is for extra workspace members
+            manifests = [],
+        )),
+    )
+    is_windows = _is_windows(ctx)
+    args = ["--extra-manifests-manifest", _runfiles_path(manifest.short_path, is_windows)]
+    runfiles = [manifest]
+    return args, runfiles
+
+def _write_config_file(ctx):
+    annotations = collect_crate_annotations(ctx.attr.annotations, str(ctx.label))
+    unexpected = []
+    for id, annotation in annotations.items():
+        if annotation.get("additive_build_file", None):
+            unexpected.append(id)
+    if unexpected:
+        fail("The following annotations use `additive_build_file` which is not supported for `crates_vendor`: {}".format(unexpected))
+
+    rendering_config = dict(json.decode(render_config()))
+
+    output_pkg = _get_output_package(ctx)
+
+    if ctx.attr.mode == "local":
+        build_file_base_template = "@{}//{}/{{name}}-{{version}}:BUILD.bazel"
+        crate_label_template = "//{}/{{name}}-{{version}}:{{target}}".format(
+            output_pkg,
+        )
+    else:
+        build_file_base_template = "@{}//{}:BUILD.{{name}}-{{version}}.bazel"
+        crate_label_template = rendering_config["crate_label_template"]
+
+    rendering_config.update({
+        "build_file_template": build_file_base_template.format(
+            ctx.workspace_name,
+            output_pkg,
+        ),
+        "crate_label_template": crate_label_template,
+        "crates_module_template": "@{}//{}:{{file}}".format(
+            ctx.workspace_name,
+            output_pkg,
+        ),
+        "repository_name": ctx.attr.repository_name or ctx.label.name,
+        "vendor_mode": ctx.attr.mode,
+    })
+
+    config_data = struct(
+        annotations = annotations,
+        rendering = rendering_config,
+        generate_build_scripts = ctx.attr.generate_build_scripts,
+        cargo_config = None,
+        supported_platform_triples = ctx.attr.supported_platform_triples,
+    )
+
+    config = _write_data_file(
+        ctx = ctx,
+        name = "cargo-bazel-config.json",
+        data = json.encode_indent(
+            config_data,
+            indent = " " * 4,
+        ),
+    )
+
+    is_windows = _is_windows(ctx)
+    args = ["--config", _runfiles_path(config.short_path, is_windows)]
+    runfiles = [config] + ctx.files.manifests
+    return args, runfiles
+
+def _crates_vendor_impl(ctx):
+    toolchain = ctx.toolchains[Label("@rules_rust//rust:toolchain")]
+    is_windows = _is_windows(ctx)
+
+    environ = {
+        "CARGO": _runfiles_path(toolchain.cargo.short_path, is_windows),
+        "RUSTC": _runfiles_path(toolchain.rustc.short_path, is_windows),
+    }
+
+    args = ["vendor"]
+
+    cargo_bazel_runfiles = []
+
+    # Allow action envs to override the use of the cargo-bazel target.
+    if CARGO_BAZEL_GENERATOR_PATH in ctx.var:
+        bin_path = ctx.var[CARGO_BAZEL_GENERATOR_PATH]
+    elif ctx.executable.cargo_bazel:
+        bin_path = _runfiles_path(ctx.executable.cargo_bazel.short_path, is_windows)
+        cargo_bazel_runfiles.append(ctx.executable.cargo_bazel)
+    else:
+        fail("{} is missing either the `cargo_bazel` attribute or the '{}' action env".format(
+            ctx.label,
+            CARGO_BAZEL_GENERATOR_PATH,
+        ))
+
+    # Generate config file
+    config_args, config_runfiles = _write_config_file(ctx)
+    args.extend(config_args)
+    cargo_bazel_runfiles.extend(config_runfiles)
+
+    # Generate splicing manifest
+    splicing_manifest_args, splicing_manifest_runfiles = _write_splicing_manifest(ctx)
+    args.extend(splicing_manifest_args)
+    cargo_bazel_runfiles.extend(splicing_manifest_runfiles)
+
+    # Generate extra-manifests manifest
+    extra_manifests_manifest_args, extra_manifests_manifest_runfiles = _write_extra_manifests_manifest(ctx)
+    args.extend(extra_manifests_manifest_args)
+    cargo_bazel_runfiles.extend(extra_manifests_manifest_runfiles)
+
+    # Optionally include buildifier
+    if ctx.attr.buildifier:
+        args.extend(["--buildifier", _runfiles_path(ctx.executable.buildifier.short_path, is_windows)])
+        cargo_bazel_runfiles.append(ctx.executable.buildifier)
+
+    # Dtermine platform specific settings
+    if is_windows:
+        extension = ".bat"
+        template = _WINDOWS_WRAPPER
+        env_template = "\nset {}={}"
+    else:
+        extension = ".sh"
+        template = _UNIX_WRAPPER
+        env_template = "{}={}"
+
+    # Write the wrapper script
+    runner = ctx.actions.declare_file(ctx.label.name + extension)
+    ctx.actions.write(
+        output = runner,
+        content = template.format(
+            env = " ".join([env_template.format(key, val) for key, val in environ.items()]),
+            bin = bin_path,
+            args = " ".join(args),
+        ),
+        is_executable = True,
+    )
+
+    return DefaultInfo(
+        files = depset([runner]),
+        runfiles = ctx.runfiles(
+            files = cargo_bazel_runfiles,
+            transitive_files = toolchain.all_files,
+        ),
+        executable = runner,
+    )
+
+crates_vendor = rule(
+    implementation = _crates_vendor_impl,
+    doc = "A rule for defining Rust dependencies (crates) and writing targets for them to the current workspace",
+    attrs = {
+        "annotations": attr.string_list_dict(
+            doc = "Extra settings to apply to crates. See [crate.annotations](#crateannotations).",
+        ),
+        "buildifier": attr.label(
+            doc = "The path to a [buildifier](https://github.com/bazelbuild/buildtools/blob/5.0.1/buildifier/README.md) binary used to format generated BUILD files.",
+            cfg = "exec",
+            executable = True,
+            default = Label("//crate_universe/private/vendor:buildifier"),
+        ),
+        "cargo_bazel": attr.label(
+            doc = (
+                "The cargo-bazel binary to use for vendoring. If this attribute is not set, then a " +
+                "`{}` action env will be used.".format(CARGO_BAZEL_GENERATOR_PATH)
+            ),
+            cfg = "exec",
+            executable = True,
+            allow_files = True,
+            default = CARGO_BAZEL_LABEL,
+        ),
+        "generate_build_scripts": attr.bool(
+            doc = (
+                "Whether or not to generate " +
+                "[cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default."
+            ),
+            default = True,
+        ),
+        "manifests": attr.label_list(
+            doc = "A list of Cargo manifests (`Cargo.toml` files).",
+            allow_files = ["Cargo.toml"],
+        ),
+        "mode": attr.string(
+            doc = (
+                "Flags determining how crates should be vendored. `local` is where crate source and BUILD files are " +
+                "written to the repository. `remote` is where only BUILD files are written and repository rules " +
+                "used to fetch source code."
+            ),
+            values = [
+                "local",
+                "remote",
+            ],
+            default = "remote",
+        ),
+        "packages": attr.string_dict(
+            doc = "A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).",
+        ),
+        "repository_name": attr.string(
+            doc = "The name of the repository to generate for `remote` vendor modes. If unset, the label name will be used",
+        ),
+        "splicing_config": attr.string(
+            doc = (
+                "The configuration flags to use for splicing Cargo maniests. Use `//crate_universe:defs.bzl\\%rsplicing_config` to " +
+                "generate the value for this field. If unset, the defaults defined there will be used."
+            ),
+        ),
+        "supported_platform_triples": attr.string_list(
+            doc = "A set of all platform triples to consider when generating dependencies.",
+            default = SUPPORTED_PLATFORM_TRIPLES,
+        ),
+        "vendor_path": attr.string(
+            doc = "The path to a directory to write files into. Absolute paths will be treated as relative to the workspace root",
+            default = "crates",
+        ),
+    },
+    executable = True,
+    toolchains = ["@rules_rust//rust:toolchain"],
+)
+
+def _crates_vendor_remote_repository_impl(repository_ctx):
+    build_file = repository_ctx.path(repository_ctx.attr.build_file)
+    defs_module = repository_ctx.path(repository_ctx.attr.defs_module)
+
+    repository_ctx.file("BUILD.bazel", repository_ctx.read(build_file))
+    repository_ctx.file("defs.bzl", repository_ctx.read(defs_module))
+    repository_ctx.file("crates.bzl", "")
+    repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format(
+        repository_ctx.name,
+    ))
+
+crates_vendor_remote_repository = repository_rule(
+    doc = "Creates a repository paired with `crates_vendor` targets using the `remote` vendor mode.",
+    implementation = _crates_vendor_remote_repository_impl,
+    attrs = {
+        "build_file": attr.label(
+            doc = "The BUILD file to use for the root package",
+            mandatory = True,
+        ),
+        "defs_module": attr.label(
+            doc = "The `defs.bzl` file to use in the repository",
+            mandatory = True,
+        ),
+    },
+)
diff --git a/third_party/rules_rust/crate_universe/private/generate_utils.bzl b/third_party/rules_rust/crate_universe/private/generate_utils.bzl
new file mode 100644
index 0000000..91e8c6e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/generate_utils.bzl
@@ -0,0 +1,410 @@
+"""Utilities directly related to the `generate` step of `cargo-bazel`."""
+
+load(":common_utils.bzl", "CARGO_BAZEL_ISOLATED", "cargo_environ", "execute")
+
+CARGO_BAZEL_GENERATOR_SHA256 = "CARGO_BAZEL_GENERATOR_SHA256"
+CARGO_BAZEL_GENERATOR_URL = "CARGO_BAZEL_GENERATOR_URL"
+CARGO_BAZEL_REPIN = "CARGO_BAZEL_REPIN"
+REPIN = "REPIN"
+
+GENERATOR_ENV_VARS = [
+    CARGO_BAZEL_GENERATOR_URL,
+    CARGO_BAZEL_GENERATOR_SHA256,
+]
+
+REPIN_ENV_VARS = [
+    REPIN,
+    CARGO_BAZEL_REPIN,
+]
+
+CRATES_REPOSITORY_ENVIRON = GENERATOR_ENV_VARS + REPIN_ENV_VARS + [
+    CARGO_BAZEL_ISOLATED,
+]
+
+def get_generator(repository_ctx, host_triple):
+    """Query network resources to locate a `cargo-bazel` binary
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        host_triple (string): A string representing the host triple
+
+    Returns:
+        tuple(path, dict): The path to a `cargo-bazel` binary and the host sha256 pairing.
+            The pairing (dict) may be `None` if there is no need to update the attribute
+    """
+    use_environ = False
+    for var in GENERATOR_ENV_VARS:
+        if var in repository_ctx.os.environ:
+            use_environ = True
+
+    output = repository_ctx.path("cargo-bazel.exe" if "win" in repository_ctx.os.name else "cargo-bazel")
+
+    # The `generator` attribute is the next highest priority behind
+    # environment variables. We check those first before deciding to
+    # use an explicitly provided variable.
+    if not use_environ and repository_ctx.attr.generator:
+        generator = repository_ctx.path(Label(repository_ctx.attr.generator))
+
+        # Resolve a few levels of symlinks to ensure we're accessing the direct binary
+        for _ in range(1, 100):
+            real_generator = generator.realpath
+            if real_generator == generator:
+                break
+            generator = real_generator
+        return generator, None
+
+    # The environment variable will take precedence if set
+    if use_environ:
+        generator_sha256 = repository_ctx.os.environ.get(CARGO_BAZEL_GENERATOR_SHA256)
+        generator_url = repository_ctx.os.environ.get(CARGO_BAZEL_GENERATOR_URL)
+    else:
+        generator_sha256 = repository_ctx.attr.generator_sha256s.get(host_triple)
+        generator_url = repository_ctx.attr.generator_urls.get(host_triple)
+
+    if not generator_url:
+        fail((
+            "No generator URL was found either in the `CARGO_BAZEL_GENERATOR_URL` " +
+            "environment variable or for the `{}` triple in the `generator_urls` attribute"
+        ).format(host_triple))
+
+    # Download the file into place
+    if generator_sha256:
+        repository_ctx.download(
+            output = output,
+            url = generator_url,
+            sha256 = generator_sha256,
+            executable = True,
+        )
+        return output, None
+
+    result = repository_ctx.download(
+        output = output,
+        url = generator_url,
+        executable = True,
+    )
+
+    return output, {host_triple: result.sha256}
+
+def render_config(
+        build_file_template = "//:BUILD.{name}-{version}.bazel",
+        crate_label_template = "@{repository}__{name}-{version}//:{target}",
+        crate_repository_template = "{repository}__{name}-{version}",
+        crates_module_template = "//:{file}",
+        default_package_name = None,
+        platforms_template = "@rules_rust//rust/platform:{triple}",
+        vendor_mode = None):
+    """Various settings used to configure rendered outputs
+
+    The template parameters each support a select number of format keys. A description of each key
+    can be found below where the supported keys for each template can be found in the parameter docs
+
+    | key | definition |
+    | --- | --- |
+    | `name` | The name of the crate. Eg `tokio` |
+    | `repository` | The rendered repository name for the crate. Directly relates to `crate_repository_template`. |
+    | `triple` | A platform triple. Eg `x86_64-unknown-linux-gnu` |
+    | `version` | The crate version. Eg `1.2.3` |
+    | `target` | The library or binary target of the crate |
+    | `file` | The basename of a file |
+
+    Args:
+        build_file_template (str, optional): The base template to use for BUILD file names. The available format keys
+            are [`{name}`, {version}`].
+        crate_label_template (str, optional): The base template to use for crate labels. The available format keys
+            are [`{repository}`, `{name}`, `{version}`, `{target}`].
+        crate_repository_template (str, optional): The base template to use for Crate label repository names. The
+            available format keys are [`{repository}`, `{name}`, `{version}`].
+        crates_module_template (str, optional): The pattern to use for the `defs.bzl` and `BUILD.bazel`
+            file names used for the crates module. The available format keys are [`{file}`].
+        default_package_name (str, optional): The default package name to in the rendered macros. This affects the
+            auto package detection of things like `all_crate_deps`.
+        platforms_template (str, optional): The base template to use for platform names.
+            See [platforms documentation](https://docs.bazel.build/versions/main/platforms.html). The available format
+            keys are [`{triple}`].
+        vendor_mode (str, optional): An optional configuration for rendirng content to be rendered into repositories.
+
+    Returns:
+        string: A json encoded struct to match the Rust `config::RenderConfig` struct
+    """
+    return json.encode(struct(
+        build_file_template = build_file_template,
+        crate_label_template = crate_label_template,
+        crate_repository_template = crate_repository_template,
+        crates_module_template = crates_module_template,
+        default_package_name = default_package_name,
+        platforms_template = platforms_template,
+        vendor_mode = vendor_mode,
+    ))
+
+def _crate_id(name, version):
+    """Creates a `cargo_bazel::config::CrateId`.
+
+    Args:
+        name (str): The name of the crate
+        version (str): The crate's version
+
+    Returns:
+        str: A serialized representation of a CrateId
+    """
+    return "{} {}".format(name, version)
+
+def collect_crate_annotations(annotations, repository_name):
+    """Deserialize and sanitize crate annotations.
+
+    Args:
+        annotations (dict): A mapping of crate names to lists of serialized annotations
+        repository_name (str): The name of the repository that owns the annotations
+
+    Returns:
+        dict: A mapping of `cargo_bazel::config::CrateId` to sets of annotations
+    """
+    annotations = {name: [json.decode(a) for a in annotation] for name, annotation in annotations.items()}
+    crate_annotations = {}
+    for name, annotation in annotations.items():
+        for (version, data) in annotation:
+            if name == "*" and version != "*":
+                fail(
+                    "Wildcard crate names must have wildcard crate versions. " +
+                    "Please update the `annotations` attribute of the {} crates_repository".format(
+                        repository_name,
+                    ),
+                )
+            id = _crate_id(name, version)
+            if id in crate_annotations:
+                fail("Found duplicate entries for {}".format(id))
+
+            crate_annotations.update({id: data})
+    return crate_annotations
+
+def _read_cargo_config(repository_ctx):
+    if repository_ctx.attr.cargo_config:
+        config = repository_ctx.path(repository_ctx.attr.cargo_config)
+        return repository_ctx.read(config)
+    return None
+
+def _get_render_config(repository_ctx):
+    if repository_ctx.attr.render_config:
+        config = dict(json.decode(repository_ctx.attr.render_config))
+    else:
+        config = dict(json.decode(render_config()))
+
+    # Add the repository name as it's very relevant to rendering.
+    config.update({"repository_name": repository_ctx.name})
+
+    return struct(**config)
+
+def generate_config(repository_ctx):
+    """Generate a config file from various attributes passed to the rule.
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+
+    Returns:
+        struct: A struct containing the path to a config and it's contents
+    """
+    annotations = collect_crate_annotations(repository_ctx.attr.annotations, repository_ctx.name)
+
+    # Load additive build files if any have been provided.
+    content = list()
+    for data in annotations.values():
+        additive_build_file_content = data.pop("additive_build_file_content", None)
+        if additive_build_file_content:
+            content.append(additive_build_file_content)
+        additive_build_file = data.pop("additive_build_file", None)
+        if additive_build_file:
+            file_path = repository_ctx.path(Label(additive_build_file))
+            content.append(repository_ctx.read(file_path))
+        data.update({"additive_build_file_content": "\n".join(content) if content else None})
+
+    config = struct(
+        generate_build_scripts = repository_ctx.attr.generate_build_scripts,
+        annotations = annotations,
+        cargo_config = _read_cargo_config(repository_ctx),
+        rendering = _get_render_config(repository_ctx),
+        supported_platform_triples = repository_ctx.attr.supported_platform_triples,
+    )
+
+    config_path = repository_ctx.path("cargo-bazel.json")
+    repository_ctx.file(
+        config_path,
+        json.encode_indent(config, indent = " " * 4),
+    )
+
+    # This was originally written to return a struct and not just the config path
+    # so splicing can have access to some rendering information embedded in the config
+    # If splicing should no longer need that info, it'd be simpler to just return a `path`.
+    return struct(
+        path = config_path,
+        info = config,
+    )
+
+def get_lockfile(repository_ctx):
+    """Locate the lockfile and identify the it's type (Cargo or Bazel).
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+
+    Returns:
+        struct: The path to the lockfile as well as it's type
+    """
+    if repository_ctx.attr.lockfile_kind == "auto":
+        if str(repository_ctx.attr.lockfile).endswith("Cargo.lock"):
+            kind = "cargo"
+        else:
+            kind = "bazel"
+    else:
+        kind = repository_ctx.attr.lockfile_kind
+
+    return struct(
+        path = repository_ctx.path(repository_ctx.attr.lockfile),
+        kind = kind,
+    )
+
+def determine_repin(repository_ctx, generator, lockfile_path, lockfile_kind, config, splicing_manifest, cargo, rustc):
+    """Use the `cargo-bazel` binary to determine whether or not dpeendencies need to be re-pinned
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        generator (path): The path to a `cargo-bazel` binary.
+        config (path): The path to a `cargo-bazel` config file. See `generate_config`.
+        splicing_manifest (path): The path to a `cargo-bazel` splicing manifest. See `create_splicing_manifest`
+        lockfile_path (path): The path to a "lock" file for reproducible outputs.
+        lockfile_kind (str): The type of lock file represented by `lockfile_path`
+        cargo (path): The path to a Cargo binary.
+        rustc (path): The path to a Rustc binary.
+
+    Returns:
+        bool: True if dependencies need to be re-pinned
+    """
+
+    # If a repin environment variable is set, always repin
+    for var in REPIN_ENV_VARS:
+        if repository_ctx.os.environ.get(var, "").lower() in ["true", "yes", "1", "on"]:
+            return True
+
+    # Cargo lockfiles should always be repinned.
+    if lockfile_kind == "cargo":
+        return True
+
+    # Run the binary to check if a repin is needed
+    args = [
+        generator,
+        "query",
+        "--lockfile",
+        lockfile_path,
+        "--config",
+        config,
+        "--splicing-manifest",
+        splicing_manifest,
+        "--cargo",
+        cargo,
+        "--rustc",
+        rustc,
+    ]
+
+    env = {
+        "CARGO": str(cargo),
+        "RUSTC": str(rustc),
+        "RUST_BACKTRACE": "full",
+    }
+
+    # Add any Cargo environment variables to the `cargo-bazel` execution
+    env.update(cargo_environ(repository_ctx))
+
+    result = execute(
+        repository_ctx = repository_ctx,
+        args = args,
+        env = env,
+    )
+
+    # If it was determined repinning should occur but there was no
+    # flag indicating repinning was requested, an error is raised
+    # since repinning should be an explicit action
+    if result.stdout.strip().lower() == "repin":
+        # buildifier: disable=print
+        print(result.stderr)
+        fail((
+            "The current `lockfile` is out of date for '{}'. Please re-run " +
+            "bazel using `CARGO_BAZEL_REPIN=true` if this is expected " +
+            "and the lockfile should be updated."
+        ).format(repository_ctx.name))
+
+    return False
+
+def execute_generator(
+        repository_ctx,
+        lockfile_path,
+        lockfile_kind,
+        generator,
+        config,
+        splicing_manifest,
+        repository_dir,
+        cargo,
+        rustc,
+        repin = False,
+        metadata = None):
+    """Execute the `cargo-bazel` binary to produce `BUILD` and `.bzl` files.
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        lockfile_path (path): The path to a "lock" file (file used for reproducible renderings).
+        lockfile_kind (str): The type of lockfile given (Cargo or Bazel).
+        generator (path): The path to a `cargo-bazel` binary.
+        config (path): The path to a `cargo-bazel` config file.
+        splicing_manifest (path): The path to a `cargo-bazel` splicing manifest. See `create_splicing_manifest`
+        repository_dir (path): The output path for the Bazel module and BUILD files.
+        cargo (path): The path of a Cargo binary.
+        rustc (path): The path of a Rustc binary.
+        repin (bool, optional): Whether or not to repin dependencies
+        metadata (path, optional): The path to a Cargo metadata json file.
+
+    Returns:
+        struct: The results of `repository_ctx.execute`.
+    """
+    repository_ctx.report_progress("Generating crate BUILD files.")
+
+    args = [
+        generator,
+        "generate",
+        "--lockfile",
+        lockfile_path,
+        "--lockfile-kind",
+        lockfile_kind,
+        "--config",
+        config,
+        "--splicing-manifest",
+        splicing_manifest,
+        "--repository-dir",
+        repository_dir,
+        "--cargo",
+        cargo,
+        "--rustc",
+        rustc,
+    ]
+
+    env = {
+        "RUST_BACKTRACE": "full",
+    }
+
+    # Some components are not required unless re-pinning is enabled
+    if repin:
+        args.extend([
+            "--repin",
+            "--metadata",
+            metadata,
+        ])
+        env.update({
+            "CARGO": str(cargo),
+            "RUSTC": str(rustc),
+        })
+
+    # Add any Cargo environment variables to the `cargo-bazel` execution
+    env.update(cargo_environ(repository_ctx))
+
+    result = execute(
+        repository_ctx = repository_ctx,
+        args = args,
+        env = env,
+    )
+
+    return result
diff --git a/third_party/rules_rust/crate_universe/private/selects.bzl b/third_party/rules_rust/crate_universe/private/selects.bzl
new file mode 100644
index 0000000..bcbad19
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/selects.bzl
@@ -0,0 +1,56 @@
+"""A helper module solving for complex select statements in rendered cargo-bazel modules"""
+
+def select_with_or(input_dict, no_match_error = ""):
+    """Drop-in replacement for `select()` that supports ORed keys.
+
+    This is notably different from [@bazel_skylib//lib:selects.bzl%selects.with_or][swo] in that
+    the input dict must have a list as it's values and they keys will continue to expand for each
+    entry instead of failing on duplicates.
+
+    Example:
+    ```starlark
+    deps = selects.with_or({
+        "//configs:one": [":dep1"],
+        ("//configs:two", "//configs:three"): [":dep2or3"],
+        "//configs:four": [":dep4"],
+        "//conditions:default": [":default"]
+    })
+    ```
+    Key labels may appear at most once anywhere in the input.
+
+    This macro eturns a native `select` that expands `("//configs:two", "//configs:three"): [":dep2or3"]` to
+    ```starlark
+    "//configs:two": [":dep2or3"],
+    "//configs:three": [":dep2or3"],
+    ```
+
+    [swo]: https://github.com/bazelbuild/bazel-skylib/blob/1.1.1/docs/selects_doc.md#selectswith_or
+
+    Args:
+        input_dict: The same dictionary `select()` takes, except keys may take
+            either the usual form `"//foo:config1"` or
+            `("//foo:config1", "//foo:config2", ...)` to signify
+            `//foo:config1` OR `//foo:config2` OR `...`.
+        no_match_error: Optional custom error to report if no condition matches.
+
+    Returns:
+        A native `select()`
+    """
+    output_dict = {}
+    for (key, value) in input_dict.items():
+        if type(key) == type(()):
+            for config_setting in key:
+                if config_setting in output_dict:
+                    output_dict[config_setting].extend(value)
+                else:
+                    output_dict[config_setting] = list(value)
+        elif key in output_dict:
+            output_dict[key].extend(value)
+        else:
+            output_dict[key] = list(value)
+
+    # return a dict with deduped lists
+    return select(
+        {key: depset(value).to_list() for key, value in output_dict.items()},
+        no_match_error = no_match_error,
+    )
diff --git a/third_party/rules_rust/crate_universe/private/splicing_utils.bzl b/third_party/rules_rust/crate_universe/private/splicing_utils.bzl
new file mode 100644
index 0000000..a419c75
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/splicing_utils.bzl
@@ -0,0 +1,223 @@
+"""Utilities directly related to the `splicing` step of `cargo-bazel`."""
+
+load(":common_utils.bzl", "cargo_environ", "execute")
+
+def splicing_config(resolver_version = "1"):
+    """arious settings used to configure Cargo manifest splicing behavior.
+
+    [rv]: https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions
+
+    Args:
+        resolver_version (str, optional): The [resolver version][rv] to use in generated Cargo
+            manifests. This flag is **only** used when splicing a manifest from direct package
+            definitions. See `crates_repository::packages`.
+
+    Returns:
+        str: A json encoded string of the parameters provided
+    """
+    return json.encode(struct(
+        resolver_version = resolver_version,
+    ))
+
+def download_extra_workspace_members(repository_ctx, cache_dir, render_template_registry_url):
+    """Download additional workspace members for use in splicing.
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        cache_dir (path): A directory in which to download and extract extra workspace members
+        render_template_registry_url (str): The base template to use for determining the crate's registry URL.
+
+    Returns:
+        list: A list of information related to the downloaded crates
+            - manifest: The path of the manifest.
+            - url: The url the manifest came from.
+            - sha256: The sha256 checksum of the new manifest.
+    """
+    manifests = []
+    extra_workspace_members = repository_ctx.attr.extra_workspace_members
+    if extra_workspace_members:
+        repository_ctx.report_progress("Downloading extra workspace members.")
+
+    for name, spec in repository_ctx.attr.extra_workspace_members.items():
+        spec = struct(**json.decode(spec))
+
+        url = render_template_registry_url
+        url = url.replace("{name}", name)
+        url = url.replace("{version}", spec.version)
+
+        if spec.sha256:
+            result = repository_ctx.download_and_extract(
+                output = cache_dir,
+                url = url,
+                sha256 = spec.sha256,
+                type = "tar.gz",
+            )
+        else:
+            result = repository_ctx.download_and_extract(
+                output = cache_dir,
+                url = url,
+                type = "tar.gz",
+            )
+
+        manifest = repository_ctx.path("{}/{}-{}/Cargo.toml".format(
+            cache_dir,
+            name,
+            spec.version,
+        ))
+
+        if not manifest.exists:
+            fail("Extra workspace member '{}' has no root Cargo.toml file".format(name))
+
+        manifests.append(struct(
+            manifest = str(manifest),
+            url = url,
+            sha256 = result.sha256,
+        ))
+
+    return manifests
+
+def kebab_case_keys(data):
+    """Ensure the key value of the data given are kebab-case
+
+    Args:
+        data (dict): A deserialized json blob
+
+    Returns:
+        dict: The same `data` but with kebab-case keys
+    """
+    return {
+        key.lower().replace("_", "-"): val
+        for (key, val) in data.items()
+    }
+
+def create_splicing_manifest(repository_ctx):
+    """Produce a manifest containing required components for splciing a new Cargo workspace
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+
+    Returns:
+        path: The path to a json encoded manifest
+    """
+    repo_dir = repository_ctx.path(".")
+
+    # Deserialize information about direct packges
+    direct_packages_info = {
+        # Ensure the data is using kebab-case as that's what `cargo_toml::DependencyDetail` expects.
+        pkg: kebab_case_keys(dict(json.decode(data)))
+        for (pkg, data) in repository_ctx.attr.packages.items()
+    }
+
+    manifests = {str(repository_ctx.path(m)): str(m) for m in repository_ctx.attr.manifests}
+
+    if repository_ctx.attr.cargo_config:
+        cargo_config = str(repository_ctx.path(repository_ctx.attr.cargo_config))
+    else:
+        cargo_config = None
+
+    # Load user configurable splicing settings
+    config = json.decode(repository_ctx.attr.splicing_config or splicing_config())
+
+    # Auto-generated splicier manifest values
+    splicing_manifest_content = {
+        "cargo_config": cargo_config,
+        "direct_packages": direct_packages_info,
+        "manifests": manifests,
+    }
+
+    # Serialize information required for splicing
+    splicing_manifest = repository_ctx.path("{}/splicing_manifest.json".format(repo_dir))
+    repository_ctx.file(
+        splicing_manifest,
+        json.encode_indent(
+            dict(dict(config).items() + splicing_manifest_content.items()),
+            indent = " " * 4,
+        ),
+    )
+
+    return splicing_manifest
+
+def splice_workspace_manifest(repository_ctx, generator, lockfile, splicing_manifest, cargo, rustc):
+    """Splice together a Cargo workspace from various other manifests and package definitions
+
+    Args:
+        repository_ctx (repository_ctx): The rule's context object.
+        generator (path): The `cargo-bazel` binary.
+        lockfile (path): The path to a "lock" file for reproducible `cargo-bazel` renderings.
+        splicing_manifest (path): The path to a splicing manifest.
+        cargo (path): The path to a Cargo binary.
+        rustc (path): The Path to a Rustc binary.
+
+    Returns:
+        path: The path to a Cargo metadata json file found in the spliced workspace root.
+    """
+    repository_ctx.report_progress("Splicing Cargo workspace.")
+    repo_dir = repository_ctx.path(".")
+
+    # Download extra workspace members
+    crates_cache_dir = repository_ctx.path("{}/.crates_cache".format(repo_dir))
+    extra_manifest_info = download_extra_workspace_members(
+        repository_ctx = repository_ctx,
+        cache_dir = crates_cache_dir,
+        render_template_registry_url = repository_ctx.attr.extra_workspace_member_url_template,
+    )
+
+    extra_manifests_manifest = repository_ctx.path("{}/extra_manifests_manifest.json".format(repo_dir))
+    repository_ctx.file(
+        extra_manifests_manifest,
+        json.encode_indent(struct(
+            manifests = extra_manifest_info,
+        ), indent = " " * 4),
+    )
+
+    cargo_workspace = repository_ctx.path("{}/cargo-bazel-splicing".format(repo_dir))
+
+    # Generate a workspace root which contains all workspace members
+    arguments = [
+        generator,
+        "splice",
+        "--workspace-dir",
+        cargo_workspace,
+        "--splicing-manifest",
+        splicing_manifest,
+        "--extra-manifests-manifest",
+        extra_manifests_manifest,
+        "--cargo",
+        cargo,
+        "--rustc",
+        rustc,
+    ]
+
+    # Splicing accepts a Cargo.lock file in some scenarios. Ensure it's passed
+    # if the lockfile is a actually a Cargo lockfile.
+    if lockfile.kind == "cargo":
+        arguments.extend([
+            "--cargo-lockfile",
+            lockfile.path,
+        ])
+
+    env = {
+        "CARGO": str(cargo),
+        "RUSTC": str(rustc),
+        "RUST_BACKTRACE": "full",
+    }
+
+    # Add any Cargo environment variables to the `cargo-bazel` execution
+    env.update(cargo_environ(repository_ctx))
+
+    execute(
+        repository_ctx = repository_ctx,
+        args = arguments,
+        env = env,
+    )
+
+    root_manifest = repository_ctx.path("{}/Cargo.toml".format(cargo_workspace))
+    if not root_manifest.exists:
+        fail("Root manifest does not exist: {}".format(root_manifest))
+
+    # This file must match the one generated in splicing
+    metadata_path = repository_ctx.path("{}/cargo-bazel-spliced-metadata.json".format(cargo_workspace))
+    if not metadata_path.exists:
+        fail("Root metadata file does not exist: {}".format(metadata_path))
+
+    return metadata_path
diff --git a/third_party/rules_rust/crate_universe/private/srcs.bzl b/third_party/rules_rust/crate_universe/private/srcs.bzl
new file mode 100644
index 0000000..acdfa61
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/srcs.bzl
@@ -0,0 +1,51 @@
+"""A generate file containing all source files used to produce `cargo-bazel`"""
+
+# Each source file is tracked as a target so the `cargo_bootstrap_repository`
+# rule will know to automatically rebuild if any of the sources changed.
+CARGO_BAZEL_SRCS = [
+    "@rules_rust//crate_universe:src/cli.rs",
+    "@rules_rust//crate_universe:src/cli/generate.rs",
+    "@rules_rust//crate_universe:src/cli/query.rs",
+    "@rules_rust//crate_universe:src/cli/splice.rs",
+    "@rules_rust//crate_universe:src/cli/vendor.rs",
+    "@rules_rust//crate_universe:src/config.rs",
+    "@rules_rust//crate_universe:src/context.rs",
+    "@rules_rust//crate_universe:src/context/crate_context.rs",
+    "@rules_rust//crate_universe:src/context/platforms.rs",
+    "@rules_rust//crate_universe:src/lib.rs",
+    "@rules_rust//crate_universe:src/lockfile.rs",
+    "@rules_rust//crate_universe:src/main.rs",
+    "@rules_rust//crate_universe:src/metadata.rs",
+    "@rules_rust//crate_universe:src/metadata/dependency.rs",
+    "@rules_rust//crate_universe:src/metadata/metadata_annotation.rs",
+    "@rules_rust//crate_universe:src/rendering.rs",
+    "@rules_rust//crate_universe:src/rendering/template_engine.rs",
+    "@rules_rust//crate_universe:src/rendering/templates/crate_build_file.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/module_build_file.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/module_bzl.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/aliases.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/binary.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/build_script.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/common_attrs.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/deps.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/library.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/crate/proc_macro.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/header.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/module/aliases_map.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/module/deps_map.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/module/repo_git.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/module/repo_http.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/starlark/glob.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/starlark/selectable_dict.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/partials/starlark/selectable_list.j2",
+    "@rules_rust//crate_universe:src/rendering/templates/vendor_module.j2",
+    "@rules_rust//crate_universe:src/splicing.rs",
+    "@rules_rust//crate_universe:src/splicing/cargo_config.rs",
+    "@rules_rust//crate_universe:src/splicing/splicer.rs",
+    "@rules_rust//crate_universe:src/test.rs",
+    "@rules_rust//crate_universe:src/utils.rs",
+    "@rules_rust//crate_universe:src/utils/starlark.rs",
+    "@rules_rust//crate_universe:src/utils/starlark/glob.rs",
+    "@rules_rust//crate_universe:src/utils/starlark/label.rs",
+    "@rules_rust//crate_universe:src/utils/starlark/select.rs",
+]
diff --git a/third_party/rules_rust/crate_universe/private/test/BUILD.bazel b/third_party/rules_rust/crate_universe/private/test/BUILD.bazel
new file mode 100644
index 0000000..c138c17
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/test/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
+
+diff_test(
+    name = "srcs_diff_test",
+    failure_message = "Please run 'bazel run //crate_universe/private:srcs_module.install'",
+    file1 = "//crate_universe/private:srcs_module",
+    file2 = "//crate_universe/private:srcs.bzl",
+    # TODO: The diff_test here fails on Windows. As does the
+    # install script. This should be fixed.
+    target_compatible_with = select({
+        "@platforms//os:linux": [],
+        "@platforms//os:macos": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }),
+)
diff --git a/third_party/rules_rust/crate_universe/private/urls.bzl b/third_party/rules_rust/crate_universe/private/urls.bzl
new file mode 100644
index 0000000..e4d615c
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/urls.bzl
@@ -0,0 +1,25 @@
+"""A file containing urls and associated sha256 values for cargo-bazel binaries
+
+This file is auto-generated for each release to match the urls and sha256s of
+the binaries produced for it.
+"""
+
+# Example:
+# {
+#     "x86_64-unknown-linux-gnu": "https://domain.com/downloads/cargo-bazel-x86_64-unknown-linux-gnu",
+#     "x86_64-apple-darwin": "https://domain.com/downloads/cargo-bazel-x86_64-apple-darwin",
+#     "x86_64-pc-windows-msvc": "https://domain.com/downloads/cargo-bazel-x86_64-pc-windows-msvc",
+# }
+CARGO_BAZEL_URLS = {}
+
+# Example:
+# {
+#     "x86_64-unknown-linux-gnu": "1d687fcc860dc8a1aa6198e531f0aee0637ed506d6a412fe2b9884ff5b2b17c0",
+#     "x86_64-apple-darwin": "0363e450125002f581d29cf632cc876225d738cfa433afa85ca557afb671eafa",
+#     "x86_64-pc-windows-msvc": "f5647261d989f63dafb2c3cb8e131b225338a790386c06cf7112e43dd9805882",
+# }
+CARGO_BAZEL_SHA256S = {}
+
+# Example:
+# Label("//crate_universe:cargo_bazel_bin")
+CARGO_BAZEL_LABEL = Label("@cargo_bazel_bootstrap//:binary")
diff --git a/third_party/rules_rust/crate_universe/private/vendor/BUILD.bazel b/third_party/rules_rust/crate_universe/private/vendor/BUILD.bazel
new file mode 100644
index 0000000..3c02387
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/vendor/BUILD.bazel
@@ -0,0 +1,11 @@
+load("//crate_universe/private:vendor_utils.bzl", "crates_vendor_deps_targets")
+
+crates_vendor_deps_targets()
+
+filegroup(
+    name = "distro",
+    srcs = glob(["*.bzl"]) + [
+        "BUILD.bazel",
+    ],
+    visibility = ["//crate_universe/private:__subpackages__"],
+)
diff --git a/third_party/rules_rust/crate_universe/private/vendor_utils.bzl b/third_party/rules_rust/crate_universe/private/vendor_utils.bzl
new file mode 100644
index 0000000..a866edd
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/private/vendor_utils.bzl
@@ -0,0 +1,74 @@
+"""Utility functions for use with the `crates_vendor` rule"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_file")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+_BUILDIFIER_VERSION = "5.0.1"
+_BUILDIFIER_URL_TEMPLATE = "https://github.com/bazelbuild/buildtools/releases/download/{version}/{bin}"
+_BUILDIFIER_SHA256S = {
+    "buildifier-darwin-amd64": "2cb0a54683633ef6de4e0491072e22e66ac9c6389051432b76200deeeeaf93fb",
+    "buildifier-darwin-arm64": "4da23315f0dccabf878c8227fddbccf35545b23b3cb6225bfcf3107689cc4364",
+    "buildifier-linux-amd64": "3ed7358c7c6a1ca216dc566e9054fd0b97a1482cb0b7e61092be887d42615c5d",
+    "buildifier-linux-arm64": "c657c628fca72b7e0446f1a542231722a10ba4321597bd6f6249a5da6060b6ff",
+    "buildifier-windows-amd64.exe": "45e13b2951e4c611d346dacdaf0aafaa484045a3e7300fbc5dd01a896a688177",
+}
+
+def crates_vendor_deps():
+    for bin, sha256 in _BUILDIFIER_SHA256S.items():
+        maybe(
+            http_file,
+            name = "cargo_bazel.{}".format(bin),
+            urls = [_BUILDIFIER_URL_TEMPLATE.format(
+                bin = bin,
+                version = _BUILDIFIER_VERSION,
+            )],
+            sha256 = sha256,
+            downloaded_file_path = "buildifier.exe",
+            executable = True,
+        )
+
+# buildifier: disable=unnamed-macro
+def crates_vendor_deps_targets():
+    """Define dependencies of the `crates_vendor` rule"""
+
+    native.config_setting(
+        name = "linux_amd64",
+        constraint_values = ["@platforms//os:linux", "@platforms//cpu:x86_64"],
+        visibility = ["//visibility:public"],
+    )
+
+    native.config_setting(
+        name = "linux_arm64",
+        constraint_values = ["@platforms//os:linux", "@platforms//cpu:arm64"],
+        visibility = ["//visibility:public"],
+    )
+
+    native.config_setting(
+        name = "macos_amd64",
+        constraint_values = ["@platforms//os:macos", "@platforms//cpu:x86_64"],
+        visibility = ["//visibility:public"],
+    )
+
+    native.config_setting(
+        name = "macos_arm64",
+        constraint_values = ["@platforms//os:macos", "@platforms//cpu:arm64"],
+        visibility = ["//visibility:public"],
+    )
+
+    native.config_setting(
+        name = "windows",
+        constraint_values = ["@platforms//os:windows"],
+        visibility = ["//visibility:public"],
+    )
+
+    native.alias(
+        name = "buildifier",
+        actual = select({
+            ":linux_amd64": "@cargo_bazel.buildifier-linux-amd64//file",
+            ":linux_arm64": "@cargo_bazel.buildifier-linux-arm64//file",
+            ":macos_amd64": "@cargo_bazel.buildifier-darwin-amd64//file",
+            ":macos_arm64": "@cargo_bazel.buildifier-darwin-arm64//file",
+            ":windows": "@cargo_bazel.buildifier-windows-amd64.exe//file",
+        }),
+        visibility = ["//visibility:public"],
+    )
diff --git a/third_party/rules_rust/crate_universe/src/cli.rs b/third_party/rules_rust/crate_universe/src/cli.rs
new file mode 100644
index 0000000..2ed27ac
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/cli.rs
@@ -0,0 +1,42 @@
+//! Command line interface entry points and utilities
+
+mod generate;
+mod query;
+mod splice;
+mod vendor;
+
+use clap::Parser;
+
+use self::generate::GenerateOptions;
+use self::query::QueryOptions;
+use self::splice::SpliceOptions;
+use self::vendor::VendorOptions;
+
+// Entrypoints
+pub use generate::generate;
+pub use query::query;
+pub use splice::splice;
+pub use vendor::vendor;
+
+#[derive(Parser, Debug)]
+#[clap(name = "cargo-bazel", about, version)]
+pub enum Options {
+    /// Generate Bazel Build files from a Cargo manifest.
+    Generate(GenerateOptions),
+
+    /// Splice together disjoint Cargo and Bazel info into a single Cargo workspace manifest.
+    Splice(SpliceOptions),
+
+    /// Query workspace info to determine whether or not a repin is needed.
+    Query(QueryOptions),
+
+    /// Vendor BUILD files to the workspace with either repository definitions or `cargo vendor` generated sources.
+    Vendor(VendorOptions),
+}
+
+// Convenience wrappers to avoid dependencies in the binary
+pub type Result<T> = anyhow::Result<T>;
+
+pub fn parse_args() -> Options {
+    Options::parse()
+}
diff --git a/third_party/rules_rust/crate_universe/src/cli/generate.rs b/third_party/rules_rust/crate_universe/src/cli/generate.rs
new file mode 100644
index 0000000..67ae868
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/cli/generate.rs
@@ -0,0 +1,142 @@
+//! The cli entrypoint for the `generate` subcommand
+
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use clap::Parser;
+
+use crate::config::Config;
+use crate::context::Context;
+use crate::lockfile::{is_cargo_lockfile, lock_context, write_lockfile, LockfileKind};
+use crate::metadata::load_metadata;
+use crate::metadata::Annotations;
+use crate::rendering::{write_outputs, Renderer};
+use crate::splicing::SplicingManifest;
+
+/// Command line options for the `generate` subcommand
+#[derive(Parser, Debug)]
+#[clap(about, version)]
+pub struct GenerateOptions {
+    /// The path to a Cargo binary to use for gathering metadata
+    #[clap(long, env = "CARGO")]
+    pub cargo: Option<PathBuf>,
+
+    /// The path to a rustc binary for use with Cargo
+    #[clap(long, env = "RUSTC")]
+    pub rustc: Option<PathBuf>,
+
+    /// The config file with information about the Bazel and Cargo workspace
+    #[clap(long)]
+    pub config: PathBuf,
+
+    /// A generated manifest of splicing inputs
+    #[clap(long)]
+    pub splicing_manifest: PathBuf,
+
+    /// The path to either a Cargo or Bazel lockfile
+    #[clap(long)]
+    pub lockfile: PathBuf,
+
+    /// The type of lockfile
+    #[clap(long)]
+    pub lockfile_kind: LockfileKind,
+
+    /// The directory of the current repository rule
+    #[clap(long)]
+    pub repository_dir: PathBuf,
+
+    /// A [Cargo config](https://doc.rust-lang.org/cargo/reference/config.html#configuration)
+    /// file to use when gathering metadata
+    #[clap(long)]
+    pub cargo_config: Option<PathBuf>,
+
+    /// Whether or not to ignore the provided lockfile and re-generate one
+    #[clap(long)]
+    pub repin: bool,
+
+    /// The path to a Cargo metadata `json` file.
+    #[clap(long)]
+    pub metadata: Option<PathBuf>,
+
+    /// If true, outputs will be printed instead of written to disk.
+    #[clap(long)]
+    pub dry_run: bool,
+}
+
+pub fn generate(opt: GenerateOptions) -> Result<()> {
+    // Load the config
+    let config = Config::try_from_path(&opt.config)?;
+
+    // Determine if the dependencies need to be repinned.
+    let mut should_repin = opt.repin;
+
+    // Cargo lockfiles must always be repinned.
+    if is_cargo_lockfile(&opt.lockfile, &opt.lockfile_kind) {
+        should_repin = true;
+    }
+
+    // Go straight to rendering if there is no need to repin
+    if !should_repin {
+        let context = Context::try_from_path(opt.lockfile)?;
+
+        // Render build files
+        let outputs = Renderer::new(config.rendering).render(&context)?;
+
+        // Write the outputs to disk
+        write_outputs(outputs, &opt.repository_dir, opt.dry_run)?;
+
+        return Ok(());
+    }
+
+    // Ensure Cargo and Rustc are available for use during generation.
+    let cargo_bin = match &opt.cargo {
+        Some(bin) => bin,
+        None => bail!("The `--cargo` argument is required when generating unpinned content"),
+    };
+    let rustc_bin = match &opt.rustc {
+        Some(bin) => bin,
+        None => bail!("The `--rustc` argument is required when generating unpinned content"),
+    };
+
+    // Ensure a path to a metadata file was provided
+    let metadata_path = match &opt.metadata {
+        Some(path) => path,
+        None => bail!("The `--metadata` argument is required when generating unpinned content"),
+    };
+
+    // Load Metadata and Lockfile
+    let (cargo_metadata, cargo_lockfile) = load_metadata(
+        metadata_path,
+        if is_cargo_lockfile(&opt.lockfile, &opt.lockfile_kind) {
+            Some(&opt.lockfile)
+        } else {
+            None
+        },
+    )?;
+
+    // Copy the rendering config for later use
+    let render_config = config.rendering.clone();
+
+    // Annotate metadata
+    let annotations = Annotations::new(cargo_metadata, cargo_lockfile, config.clone())?;
+
+    // Generate renderable contexts for earch package
+    let context = Context::new(annotations)?;
+
+    // Render build files
+    let outputs = Renderer::new(render_config).render(&context)?;
+
+    // Write outputs
+    write_outputs(outputs, &opt.repository_dir, opt.dry_run)?;
+
+    // Ensure Bazel lockfiles are written to disk so future generations can be short-circuted.
+    if matches!(opt.lockfile_kind, LockfileKind::Bazel) {
+        let splicing_manifest = SplicingManifest::try_from_path(&opt.splicing_manifest)?;
+
+        let lockfile = lock_context(context, &config, &splicing_manifest, cargo_bin, rustc_bin)?;
+
+        write_lockfile(lockfile, &opt.lockfile, opt.dry_run)?;
+    }
+
+    Ok(())
+}
diff --git a/third_party/rules_rust/crate_universe/src/cli/query.rs b/third_party/rules_rust/crate_universe/src/cli/query.rs
new file mode 100644
index 0000000..668f64f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/cli/query.rs
@@ -0,0 +1,87 @@
+//! The cli entrypoint for the `query` subcommand
+
+use std::fs;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+
+use crate::config::Config;
+use crate::context::Context;
+use crate::lockfile::Digest;
+use crate::splicing::SplicingManifest;
+
+/// Command line options for the `query` subcommand
+#[derive(Parser, Debug)]
+#[clap(about, version)]
+pub struct QueryOptions {
+    /// The lockfile path for reproducible Cargo->Bazel renderings
+    #[clap(long)]
+    pub lockfile: PathBuf,
+
+    /// The config file with information about the Bazel and Cargo workspace
+    #[clap(long)]
+    pub config: PathBuf,
+
+    /// A generated manifest of splicing inputs
+    #[clap(long)]
+    pub splicing_manifest: PathBuf,
+
+    /// The path to a Cargo binary to use for gathering metadata
+    #[clap(long, env = "CARGO")]
+    pub cargo: PathBuf,
+
+    /// The path to a rustc binary for use with Cargo
+    #[clap(long, env = "RUSTC")]
+    pub rustc: PathBuf,
+}
+
+/// Determine if the current lockfile needs to be re-pinned
+pub fn query(opt: QueryOptions) -> Result<()> {
+    // Read the lockfile
+    let content = match fs::read_to_string(&opt.lockfile) {
+        Ok(c) => c,
+        Err(_) => return announce_repin("Unable to read lockfile"),
+    };
+
+    // Deserialize it so we can easily compare it with
+    let lockfile: Context = match serde_json::from_str(&content) {
+        Ok(ctx) => ctx,
+        Err(_) => return announce_repin("Could not load lockfile"),
+    };
+
+    // Check to see if a digest has been set
+    let digest = match &lockfile.checksum {
+        Some(d) => d.clone(),
+        None => return announce_repin("No digest provided in lockfile"),
+    };
+
+    // Load the config file
+    let config = Config::try_from_path(&opt.config)?;
+
+    let splicing_manifest = SplicingManifest::try_from_path(&opt.splicing_manifest)?;
+
+    // Generate a new digest so we can compare it with the one in the lockfile
+    let expected = Digest::new(
+        &lockfile,
+        &config,
+        &splicing_manifest,
+        &opt.cargo,
+        &opt.rustc,
+    )?;
+    if digest != expected {
+        return announce_repin(&format!(
+            "Digests do not match: {:?} != {:?}",
+            digest, expected
+        ));
+    }
+
+    // There is no need to repin
+    Ok(())
+}
+
+fn announce_repin(reason: &str) -> Result<()> {
+    eprintln!("{}", reason);
+    println!("repin");
+    Ok(())
+}
diff --git a/third_party/rules_rust/crate_universe/src/cli/splice.rs b/third_party/rules_rust/crate_universe/src/cli/splice.rs
new file mode 100644
index 0000000..cb8ba20
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/cli/splice.rs
@@ -0,0 +1,90 @@
+//! The cli entrypoint for the `splice` subcommand
+
+use std::path::PathBuf;
+
+use clap::Parser;
+
+use crate::cli::Result;
+use crate::metadata::{write_metadata, Generator, MetadataGenerator};
+use crate::splicing::{
+    generate_lockfile, ExtraManifestsManifest, Splicer, SplicingManifest, WorkspaceMetadata,
+};
+
+/// Command line options for the `splice` subcommand
+#[derive(Parser, Debug)]
+#[clap(about, version)]
+pub struct SpliceOptions {
+    /// A generated manifest of splicing inputs
+    #[clap(long)]
+    pub splicing_manifest: PathBuf,
+
+    /// A generated manifest of "extra workspace members"
+    #[clap(long)]
+    pub extra_manifests_manifest: PathBuf,
+
+    /// A Cargo lockfile (Cargo.lock).
+    #[clap(long)]
+    pub cargo_lockfile: Option<PathBuf>,
+
+    /// The directory in which to build the workspace. A `Cargo.toml` file
+    /// should always be produced within this directory.
+    #[clap(long)]
+    pub workspace_dir: PathBuf,
+
+    /// If true, outputs will be printed instead of written to disk.
+    #[clap(long)]
+    pub dry_run: bool,
+
+    /// The path to a Cargo configuration file.
+    #[clap(long)]
+    pub cargo_config: Option<PathBuf>,
+
+    /// The path to a Cargo binary to use for gathering metadata
+    #[clap(long, env = "CARGO")]
+    pub cargo: PathBuf,
+
+    /// The path to a rustc binary for use with Cargo
+    #[clap(long, env = "RUSTC")]
+    pub rustc: PathBuf,
+}
+
+/// Combine a set of disjoint manifests into a single workspace.
+pub fn splice(opt: SpliceOptions) -> Result<()> {
+    // Load the all config files required for splicing a workspace
+    let splicing_manifest = SplicingManifest::try_from_path(&opt.splicing_manifest)?;
+    let extra_manifests_manifest =
+        ExtraManifestsManifest::try_from_path(opt.extra_manifests_manifest)?;
+
+    // Generate a splicer for creating a Cargo workspace manifest
+    let splicer = Splicer::new(
+        opt.workspace_dir,
+        splicing_manifest,
+        extra_manifests_manifest,
+    )?;
+
+    // Splice together the manifest
+    let manifest_path = splicer.splice_workspace()?;
+
+    // Generate a lockfile
+    let cargo_lockfile =
+        generate_lockfile(&manifest_path, &opt.cargo_lockfile, &opt.cargo, &opt.rustc)?;
+
+    // Write the registry url info to the manifest now that a lockfile has been generated
+    WorkspaceMetadata::write_registry_urls(&cargo_lockfile, &manifest_path)?;
+
+    // Write metadata to the workspace for future reuse
+    let (cargo_metadata, _) = Generator::new()
+        .with_cargo(opt.cargo)
+        .with_rustc(opt.rustc)
+        .generate(&manifest_path.as_path_buf())?;
+
+    // Write metadata next to the manifest
+    let metadata_path = manifest_path
+        .as_path_buf()
+        .parent()
+        .expect("Newly spliced cargo manifest has no parent directory")
+        .join("cargo-bazel-spliced-metadata.json");
+    write_metadata(&metadata_path, &cargo_metadata)?;
+
+    Ok(())
+}
diff --git a/third_party/rules_rust/crate_universe/src/cli/vendor.rs b/third_party/rules_rust/crate_universe/src/cli/vendor.rs
new file mode 100644
index 0000000..68e107f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/cli/vendor.rs
@@ -0,0 +1,167 @@
+//! The cli entrypoint for the `vendor` subcommand
+
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::{self, ExitStatus};
+
+use anyhow::{bail, Context as AnyhowContext, Result};
+use clap::Parser;
+
+use crate::config::{Config, VendorMode};
+use crate::context::Context;
+use crate::metadata::{Annotations, VendorGenerator};
+use crate::metadata::{Generator, MetadataGenerator};
+use crate::rendering::{render_module_label, write_outputs, Renderer};
+use crate::splicing::{
+    generate_lockfile, ExtraManifestsManifest, Splicer, SplicingManifest, WorkspaceMetadata,
+};
+
+/// Command line options for the `vendor` subcommand
+#[derive(Parser, Debug)]
+#[clap(about, version)]
+pub struct VendorOptions {
+    /// The path to a Cargo binary to use for gathering metadata
+    #[clap(long, env = "CARGO")]
+    pub cargo: PathBuf,
+
+    /// The path to a rustc binary for use with Cargo
+    #[clap(long, env = "RUSTC")]
+    pub rustc: PathBuf,
+
+    /// The path to a buildifier binary for formatting generated BUILD files
+    #[clap(long)]
+    pub buildifier: Option<PathBuf>,
+
+    /// The config file with information about the Bazel and Cargo workspace
+    #[clap(long)]
+    pub config: PathBuf,
+
+    /// A generated manifest of splicing inputs
+    #[clap(long)]
+    pub splicing_manifest: PathBuf,
+
+    /// The path to a Cargo lockfile
+    #[clap(long)]
+    pub cargo_lockfile: Option<PathBuf>,
+
+    /// A [Cargo config](https://doc.rust-lang.org/cargo/reference/config.html#configuration)
+    /// file to use when gathering metadata
+    #[clap(long)]
+    pub cargo_config: Option<PathBuf>,
+
+    /// The path to a Cargo metadata `json` file.
+    #[clap(long)]
+    pub metadata: Option<PathBuf>,
+
+    /// A generated manifest of "extra workspace members"
+    #[clap(long)]
+    pub extra_manifests_manifest: PathBuf,
+
+    /// The directory in which to build the workspace. A `Cargo.toml` file
+    /// should always be produced within this directory.
+    #[clap(long, env = "BUILD_WORKSPACE_DIRECTORY")]
+    pub workspace_dir: PathBuf,
+
+    /// If true, outputs will be printed instead of written to disk.
+    #[clap(long)]
+    pub dry_run: bool,
+}
+
+/// Run buildifier on a given file.
+fn buildifier_format(bin: &Path, file: &Path) -> Result<ExitStatus> {
+    let status = process::Command::new(bin)
+        .args(["-lint=fix", "-mode=fix", "-warnings=all"])
+        .arg(file)
+        .status()
+        .context("Failed to apply buildifier fixes")?;
+
+    if !status.success() {
+        bail!(status)
+    }
+
+    Ok(status)
+}
+
+pub fn vendor(opt: VendorOptions) -> Result<()> {
+    // Load the all config files required for splicing a workspace
+    let splicing_manifest =
+        SplicingManifest::try_from_path(&opt.splicing_manifest)?.absoulutize(&opt.workspace_dir);
+    let extra_manifests_manifest =
+        ExtraManifestsManifest::try_from_path(opt.extra_manifests_manifest)?.absoulutize();
+
+    let temp_dir = tempfile::tempdir().context("Failed to create temporary directory")?;
+
+    // Generate a splicer for creating a Cargo workspace manifest
+    let splicer = Splicer::new(
+        PathBuf::from(temp_dir.as_ref()),
+        splicing_manifest,
+        extra_manifests_manifest,
+    )
+    .context("Failed to crate splicer")?;
+
+    // Splice together the manifest
+    let manifest_path = splicer
+        .splice_workspace()
+        .context("Failed to splice workspace")?;
+
+    // Generate a lockfile
+    let cargo_lockfile =
+        generate_lockfile(&manifest_path, &opt.cargo_lockfile, &opt.cargo, &opt.rustc)?;
+
+    // Write the registry url info to the manifest now that a lockfile has been generated
+    WorkspaceMetadata::write_registry_urls(&cargo_lockfile, &manifest_path)?;
+
+    // Write metadata to the workspace for future reuse
+    let (cargo_metadata, cargo_lockfile) = Generator::new()
+        .with_cargo(opt.cargo.clone())
+        .with_rustc(opt.rustc.clone())
+        .generate(&manifest_path.as_path_buf())?;
+
+    // Load the config from disk
+    let config = Config::try_from_path(&opt.config)?;
+
+    // Annotate metadata
+    let annotations = Annotations::new(cargo_metadata, cargo_lockfile, config.clone())?;
+
+    // Generate renderable contexts for earch package
+    let context = Context::new(annotations)?;
+
+    // Render build files
+    let outputs = Renderer::new(config.rendering.clone()).render(&context)?;
+
+    // Cache the file names for potential use with buildifier
+    let file_names: BTreeSet<PathBuf> = outputs.keys().cloned().collect();
+
+    // First ensure vendoring and rendering happen in a clean directory
+    let vendor_dir_label = render_module_label(&config.rendering.crates_module_template, "BUILD")?;
+    let vendor_dir = opt
+        .workspace_dir
+        .join(vendor_dir_label.package.unwrap_or_default());
+    if vendor_dir.exists() {
+        fs::remove_dir_all(&vendor_dir)
+            .with_context(|| format!("Failed to delete {}", vendor_dir.display()))?;
+    }
+
+    // Vendor the crates from the spliced workspace
+    if matches!(config.rendering.vendor_mode, Some(VendorMode::Local)) {
+        VendorGenerator::new(opt.cargo.clone(), opt.rustc.clone())
+            .generate(manifest_path.as_path_buf(), &vendor_dir)
+            .context("Failed to vendor dependencies")?;
+    }
+
+    // Write outputs
+    write_outputs(outputs, &opt.workspace_dir, opt.dry_run)
+        .context("Failed writing output files")?;
+
+    // Optionally apply buildifier fixes
+    if let Some(buildifier_bin) = opt.buildifier {
+        for file in file_names {
+            let file_path = opt.workspace_dir.join(file);
+            buildifier_format(&buildifier_bin, &file_path)
+                .with_context(|| format!("Failed to run buildifier on {}", file_path.display()))?;
+        }
+    }
+
+    Ok(())
+}
diff --git a/third_party/rules_rust/crate_universe/src/config.rs b/third_party/rules_rust/crate_universe/src/config.rs
new file mode 100644
index 0000000..66e3a7e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/config.rs
@@ -0,0 +1,495 @@
+//! A module for configuration information
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::convert::AsRef;
+use std::iter::Sum;
+use std::ops::Add;
+use std::path::Path;
+use std::{fmt, fs};
+
+use anyhow::Result;
+use cargo_lock::package::source::GitReference;
+use cargo_metadata::Package;
+use semver::VersionReq;
+use serde::de::Visitor;
+use serde::{Deserialize, Serialize, Serializer};
+
+/// Representations of different kinds of crate vendoring into workspaces.
+#[derive(Debug, Serialize, Deserialize, Hash, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum VendorMode {
+    /// Crates having full source being vendored into a workspace
+    Local,
+
+    /// Crates having only BUILD files with repository rules vendored into a workspace
+    Remote,
+}
+
+impl std::fmt::Display for VendorMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(
+            match self {
+                VendorMode::Local => "local",
+                VendorMode::Remote => "remote",
+            },
+            f,
+        )
+    }
+}
+
+#[derive(Debug, Default, Hash, Serialize, Deserialize, Clone)]
+#[serde(deny_unknown_fields)]
+pub struct RenderConfig {
+    /// The name of the repository being rendered
+    pub repository_name: String,
+
+    /// The pattern to use for BUILD file names.
+    /// Eg. `//:BUILD.{name}-{version}.bazel`
+    #[serde(default = "default_build_file_template")]
+    pub build_file_template: String,
+
+    /// The pattern to use for a crate target.
+    /// Eg. `@{repository}__{name}-{version}//:{target}`
+    #[serde(default = "default_crate_label_template")]
+    pub crate_label_template: String,
+
+    /// The pattern to use for the `defs.bzl` and `BUILD.bazel`
+    /// file names used for the crates module.
+    /// Eg. `//:{file}`
+    #[serde(default = "default_crates_module_template")]
+    pub crates_module_template: String,
+
+    /// The pattern used for a crate's repository name.
+    /// Eg. `{repository}__{name}-{version}`
+    #[serde(default = "default_crate_repository_template")]
+    pub crate_repository_template: String,
+
+    /// The default of the `package_name` parameter to use for the module macros like `all_crate_deps`.
+    /// In general, this should be be unset to allow the macros to do auto-detection in the analysis phase.
+    pub default_package_name: Option<String>,
+
+    /// The pattern to use for platform constraints.
+    /// Eg. `@rules_rust//rust/platform:{triple}`.
+    #[serde(default = "default_platforms_template")]
+    pub platforms_template: String,
+
+    /// An optional configuration for rendirng content to be rendered into repositories.
+    pub vendor_mode: Option<VendorMode>,
+}
+
+fn default_build_file_template() -> String {
+    "//:BUILD.{name}-{version}.bazel".to_owned()
+}
+
+fn default_crates_module_template() -> String {
+    "//:{file}".to_owned()
+}
+
+fn default_crate_label_template() -> String {
+    "@{repository}__{name}-{version}//:{target}".to_owned()
+}
+
+fn default_crate_repository_template() -> String {
+    "{repository}__{name}-{version}".to_owned()
+}
+
+fn default_platforms_template() -> String {
+    "@rules_rust//rust/platform:{triple}".to_owned()
+}
+
+/// A representation of some Git identifier used to represent the "revision" or "pin" of a checkout.
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Commitish {
+    /// From a tag.
+    Tag(String),
+
+    /// From the HEAD of a branch.
+    Branch(String),
+
+    /// From a specific revision.
+    Rev(String),
+}
+
+impl From<GitReference> for Commitish {
+    fn from(git_ref: GitReference) -> Self {
+        match git_ref {
+            GitReference::Tag(v) => Self::Tag(v),
+            GitReference::Branch(v) => Self::Branch(v),
+            GitReference::Rev(v) => Self::Rev(v),
+        }
+    }
+}
+
+/// Information representing deterministic identifiers for some remote asset.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum Checksumish {
+    Http {
+        /// The sha256 digest of an http archive
+        sha256: Option<String>,
+    },
+    Git {
+        /// The revision of the git repository
+        commitsh: Commitish,
+
+        /// An optional date, not after the specified commit; the argument is
+        /// not allowed if a tag is specified (which allows cloning with depth
+        /// 1).
+        shallow_since: Option<String>,
+    },
+}
+
+#[derive(Debug, Default, Hash, Deserialize, Serialize, Clone)]
+pub struct CrateAnnotations {
+    /// Determins whether or not Cargo build scripts should be generated for the current package
+    pub gen_build_script: Option<bool>,
+
+    /// Additional data to pass to
+    /// [deps](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-deps) attribute.
+    pub deps: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to
+    /// [proc_macro_deps](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-proc_macro_deps) attribute.
+    pub proc_macro_deps: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to  the target's
+    /// [crate_features](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-crate_features) attribute.
+    pub crate_features: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to  the target's
+    /// [data](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-data) attribute.
+    pub data: Option<BTreeSet<String>>,
+
+    /// An optional glob pattern to set on the
+    /// [data](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-data) attribute.
+    pub data_glob: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to
+    /// [compile_data](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-compile_data) attribute.
+    pub compile_data: Option<BTreeSet<String>>,
+
+    /// An optional glob pattern to set on the
+    /// [compile_data](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-compile_data) attribute.
+    pub compile_data_glob: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to  the target's
+    /// [rustc_env](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-rustc_env) attribute.
+    pub rustc_env: Option<BTreeMap<String, String>>,
+
+    /// Additional data to pass to  the target's
+    /// [rustc_env_files](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-rustc_env_files) attribute.
+    pub rustc_env_files: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to the target's
+    /// [rustc_flags](https://bazelbuild.github.io/rules_rust/defs.html#rust_library-rustc_flags) attribute.
+    pub rustc_flags: Option<Vec<String>>,
+
+    /// Additional dependencies to pass to a build script's
+    /// [deps](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-deps) attribute.
+    pub build_script_deps: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to a build script's
+    /// [proc_macro_deps](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-proc_macro_deps) attribute.
+    pub build_script_proc_macro_deps: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to a build script's
+    /// [build_script_data](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-data) attribute.
+    pub build_script_data: Option<BTreeSet<String>>,
+
+    /// Additional data to pass to a build script's
+    /// [tools](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-tools) attribute.
+    pub build_script_tools: Option<BTreeSet<String>>,
+
+    /// An optional glob pattern to set on the
+    /// [build_script_data](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-build_script_env) attribute.
+    pub build_script_data_glob: Option<BTreeSet<String>>,
+
+    /// Additional environment variables to pass to a build script's
+    /// [build_script_env](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-rustc_env) attribute.
+    pub build_script_env: Option<BTreeMap<String, String>>,
+
+    /// Additional rustc_env flags to pass to a build script's
+    /// [rustc_env](https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script-rustc_env) attribute.
+    pub build_script_rustc_env: Option<BTreeMap<String, String>>,
+
+    /// A scratch pad used to write arbitrary text to target BUILD files.
+    pub additive_build_file_content: Option<String>,
+
+    /// For git sourced crates, this is a the
+    /// [git_repository::shallow_since](https://docs.bazel.build/versions/main/repo/git.html#new_git_repository-shallow_since) attribute.
+    pub shallow_since: Option<String>,
+
+    /// The `patch_args` attribute of a Bazel repository rule. See
+    /// [http_archive.patch_args](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_args)
+    pub patch_args: Option<Vec<String>>,
+
+    /// The `patch_tool` attribute of a Bazel repository rule. See
+    /// [http_archive.patch_tool](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_tool)
+    pub patch_tool: Option<String>,
+
+    /// The `patches` attribute of a Bazel repository rule. See
+    /// [http_archive.patches](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patches)
+    pub patches: Option<BTreeSet<String>>,
+}
+
+macro_rules! joined_extra_member {
+    ($lhs:expr, $rhs:expr, $fn_new:expr, $fn_extend:expr) => {
+        if let Some(lhs) = $lhs {
+            if let Some(rhs) = $rhs {
+                let mut new = $fn_new();
+                $fn_extend(&mut new, lhs);
+                $fn_extend(&mut new, rhs);
+                Some(new)
+            } else {
+                Some(lhs)
+            }
+        } else if $rhs.is_some() {
+            $rhs
+        } else {
+            None
+        }
+    };
+}
+
+impl Add for CrateAnnotations {
+    type Output = CrateAnnotations;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let shallow_since = if self.shallow_since.is_some() {
+            self.shallow_since
+        } else if rhs.shallow_since.is_some() {
+            rhs.shallow_since
+        } else {
+            None
+        };
+
+        let patch_tool = if self.patch_tool.is_some() {
+            self.patch_tool
+        } else if rhs.patch_tool.is_some() {
+            rhs.patch_tool
+        } else {
+            None
+        };
+
+        let gen_build_script = if self.gen_build_script.is_some() {
+            self.gen_build_script
+        } else if rhs.gen_build_script.is_some() {
+            rhs.gen_build_script
+        } else {
+            None
+        };
+
+        let concat_string = |lhs: &mut String, rhs: String| {
+            *lhs = format!("{}{}", lhs, rhs);
+        };
+
+        #[rustfmt::skip]
+        let output = CrateAnnotations {
+            gen_build_script,
+            deps: joined_extra_member!(self.deps, rhs.deps, BTreeSet::new, BTreeSet::extend),
+            proc_macro_deps: joined_extra_member!(self.proc_macro_deps, rhs.proc_macro_deps, BTreeSet::new, BTreeSet::extend),
+            crate_features: joined_extra_member!(self.crate_features, rhs.crate_features, BTreeSet::new, BTreeSet::extend),
+            data: joined_extra_member!(self.data, rhs.data, BTreeSet::new, BTreeSet::extend),
+            data_glob: joined_extra_member!(self.data_glob, rhs.data_glob, BTreeSet::new, BTreeSet::extend),
+            compile_data: joined_extra_member!(self.compile_data, rhs.compile_data, BTreeSet::new, BTreeSet::extend),
+            compile_data_glob: joined_extra_member!(self.compile_data_glob, rhs.compile_data_glob, BTreeSet::new, BTreeSet::extend),
+            rustc_env: joined_extra_member!(self.rustc_env, rhs.rustc_env, BTreeMap::new, BTreeMap::extend),
+            rustc_env_files: joined_extra_member!(self.rustc_env_files, rhs.rustc_env_files, BTreeSet::new, BTreeSet::extend),
+            rustc_flags: joined_extra_member!(self.rustc_flags, rhs.rustc_flags, Vec::new, Vec::extend),
+            build_script_deps: joined_extra_member!(self.build_script_deps, rhs.build_script_deps, BTreeSet::new, BTreeSet::extend),
+            build_script_proc_macro_deps: joined_extra_member!(self.build_script_proc_macro_deps, rhs.build_script_proc_macro_deps, BTreeSet::new, BTreeSet::extend),
+            build_script_data: joined_extra_member!(self.build_script_data, rhs.build_script_data, BTreeSet::new, BTreeSet::extend),
+            build_script_tools: joined_extra_member!(self.build_script_tools, rhs.build_script_tools, BTreeSet::new, BTreeSet::extend),
+            build_script_data_glob: joined_extra_member!(self.build_script_data_glob, rhs.build_script_data_glob, BTreeSet::new, BTreeSet::extend),
+            build_script_env: joined_extra_member!(self.build_script_env, rhs.build_script_env, BTreeMap::new, BTreeMap::extend),
+            build_script_rustc_env: joined_extra_member!(self.build_script_rustc_env, rhs.build_script_rustc_env, BTreeMap::new, BTreeMap::extend),
+            additive_build_file_content: joined_extra_member!(self.additive_build_file_content, rhs.additive_build_file_content, String::new, concat_string),
+            shallow_since,
+            patch_args: joined_extra_member!(self.patch_args, rhs.patch_args, Vec::new, Vec::extend),
+            patch_tool,
+            patches: joined_extra_member!(self.patches, rhs.patches, BTreeSet::new, BTreeSet::extend),
+        };
+
+        output
+    }
+}
+
+impl Sum for CrateAnnotations {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(CrateAnnotations::default(), |a, b| a + b)
+    }
+}
+
+/// A unique identifier for Crates
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)]
+pub struct CrateId {
+    /// The name of the crate
+    pub name: String,
+
+    /// The crate's semantic version
+    pub version: String,
+}
+
+impl CrateId {
+    /// Construct a new [CrateId]
+    pub fn new(name: String, version: String) -> Self {
+        Self { name, version }
+    }
+
+    /// Compares a [CrateId] against a [cargo_metadata::Package].
+    pub fn matches(&self, package: &Package) -> bool {
+        // If the package name does not match, it's obviously
+        // not the right package
+        if self.name != "*" && self.name != package.name {
+            return false;
+        }
+
+        // First see if the package version matches exactly
+        if package.version.to_string() == self.version {
+            return true;
+        }
+
+        // Next, check to see if the version provided is a semver req and
+        // check if the package matches the condition
+        if let Ok(semver) = VersionReq::parse(&self.version) {
+            if semver.matches(&package.version) {
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+impl From<&Package> for CrateId {
+    fn from(package: &Package) -> Self {
+        Self {
+            name: package.name.clone(),
+            version: package.version.to_string(),
+        }
+    }
+}
+
+impl Serialize for CrateId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&format!("{} {}", self.name, self.version))
+    }
+}
+
+struct CrateIdVisitor;
+impl<'de> Visitor<'de> for CrateIdVisitor {
+    type Value = CrateId;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("Expected string value of `{name} {version}`.")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        v.rsplit_once(' ')
+            .map(|(name, version)| CrateId {
+                name: name.to_string(),
+                version: version.to_string(),
+            })
+            .ok_or_else(|| {
+                E::custom(format!(
+                    "Expected string value of `{{name}} {{version}}`. Got '{}'",
+                    v
+                ))
+            })
+    }
+}
+
+impl<'de> Deserialize<'de> for CrateId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_str(CrateIdVisitor)
+    }
+}
+
+impl std::fmt::Display for CrateId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&format!("{} {}", self.name, self.version), f)
+    }
+}
+
+/// Workspace specific settings to control how targets are generated
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+#[serde(deny_unknown_fields)]
+pub struct Config {
+    /// Whether or not to generate Cargo build scripts by default
+    pub generate_build_scripts: bool,
+
+    /// Additional settings to apply to generated crates
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub annotations: BTreeMap<CrateId, CrateAnnotations>,
+
+    /// Settings used to determine various render info
+    pub rendering: RenderConfig,
+
+    /// The contents of a Cargo configuration file
+    pub cargo_config: Option<toml::Value>,
+
+    /// A set of platform triples to use in generated select statements
+    #[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
+    pub supported_platform_triples: BTreeSet<String>,
+}
+
+impl Config {
+    pub fn try_from_path<T: AsRef<Path>>(path: T) -> Result<Self> {
+        let data = fs::read_to_string(path)?;
+        Ok(serde_json::from_str(&data)?)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::test::*;
+
+    #[test]
+    fn test_crate_id_serde() {
+        let id: CrateId = serde_json::from_str("\"crate 0.1.0\"").unwrap();
+        assert_eq!(id, CrateId::new("crate".to_owned(), "0.1.0".to_owned()));
+        assert_eq!(serde_json::to_string(&id).unwrap(), "\"crate 0.1.0\"");
+    }
+
+    #[test]
+    fn test_crate_id_serde_semver() {
+        let semver_id: CrateId = serde_json::from_str("\"crate *\"").unwrap();
+        assert_eq!(semver_id, CrateId::new("crate".to_owned(), "*".to_owned()));
+        assert_eq!(serde_json::to_string(&semver_id).unwrap(), "\"crate *\"");
+    }
+
+    #[test]
+    fn test_crate_id_matches() {
+        let mut package = mock_cargo_metadata_package();
+        let id = CrateId::new("mock-pkg".to_owned(), "0.1.0".to_owned());
+
+        package.version = cargo_metadata::Version::new(0, 1, 0);
+        assert!(id.matches(&package));
+
+        package.version = cargo_metadata::Version::new(1, 0, 0);
+        assert!(!id.matches(&package));
+    }
+
+    #[test]
+    fn test_crate_id_semver_matches() {
+        let mut package = mock_cargo_metadata_package();
+        package.version = cargo_metadata::Version::new(1, 0, 0);
+        let mut id = CrateId::new("mock-pkg".to_owned(), "0.1.0".to_owned());
+
+        id.version = "*".to_owned();
+        assert!(id.matches(&package));
+
+        id.version = "<1".to_owned();
+        assert!(!id.matches(&package));
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/context.rs b/third_party/rules_rust/crate_universe/src/context.rs
new file mode 100644
index 0000000..912cd80
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/context.rs
@@ -0,0 +1,511 @@
+//! Convert annotated metadata into a renderable context
+
+pub mod crate_context;
+mod platforms;
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use crate::config::CrateId;
+use crate::context::crate_context::{CrateContext, CrateDependency, Rule};
+use crate::context::platforms::resolve_cfg_platforms;
+use crate::lockfile::Digest;
+use crate::metadata::Annotations;
+use crate::utils::starlark::{Select, SelectList};
+
+pub use self::crate_context::*;
+
+/// A struct containing information about a Cargo dependency graph in an easily to consume
+/// format for rendering reproducible Bazel targets.
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+pub struct Context {
+    /// The collective checksum of all inputs to the context
+    pub checksum: Option<Digest>,
+
+    /// The collection of all crates that make up the dependency graph
+    pub crates: BTreeMap<CrateId, CrateContext>,
+
+    /// A subset of only crates with binary targets
+    pub binary_crates: BTreeSet<CrateId>,
+
+    /// A subset of workspace members mapping to their workspace
+    /// path relative to the workspace root
+    pub workspace_members: BTreeMap<CrateId, String>,
+
+    /// A mapping of `cfg` flags to platform triples supporting the configuration
+    pub conditions: BTreeMap<String, BTreeSet<String>>,
+}
+
+impl Context {
+    pub fn try_from_path<T: AsRef<Path>>(path: T) -> Result<Self> {
+        let data = fs::read_to_string(path.as_ref())?;
+        Ok(serde_json::from_str(&data)?)
+    }
+
+    pub fn new(annotations: Annotations) -> Result<Self> {
+        // Build a map of crate contexts
+        let crates: BTreeMap<CrateId, CrateContext> = annotations
+            .metadata
+            .crates
+            .iter()
+            // Convert the crate annotations into more renderable contexts
+            .map(|(_, annotation)| {
+                let context = CrateContext::new(
+                    annotation,
+                    &annotations.metadata.packages,
+                    &annotations.lockfile.crates,
+                    &annotations.pairred_extras,
+                    annotations.config.generate_build_scripts,
+                );
+                let id = CrateId::new(context.name.clone(), context.version.clone());
+                (id, context)
+            })
+            .collect();
+
+        // Filter for any crate that contains a binary
+        let binary_crates: BTreeSet<CrateId> = crates
+            .iter()
+            .filter(|(_, ctx)| ctx.targets.iter().any(|t| matches!(t, Rule::Binary(..))))
+            // Only consider remote repositories (so non-workspace members).
+            .filter(|(_, ctx)| ctx.repository.is_some())
+            .map(|(id, _)| id.clone())
+            .collect();
+
+        // Given a list of all conditional dependencies, build a set of platform
+        // triples which satsify the conditions.
+        let conditions = resolve_cfg_platforms(
+            crates.values().collect(),
+            &annotations.config.supported_platform_triples,
+        )?;
+
+        // Generate a list of all workspace members
+        let workspace_members = annotations
+            .metadata
+            .workspace_members
+            .iter()
+            .filter_map(|id| {
+                let pkg = &annotations.metadata.packages[id];
+                let package_path_id = match Self::get_package_path_id(
+                    pkg,
+                    &annotations.metadata.workspace_root,
+                    &annotations.metadata.workspace_metadata.workspace_prefix,
+                    &annotations.metadata.workspace_metadata.package_prefixes,
+                ) {
+                    Ok(id) => id,
+                    Err(e) => return Some(Err(e)),
+                };
+                let crate_id = CrateId::new(pkg.name.clone(), pkg.version.to_string());
+
+                // Crates that have repository information are not considered workspace members.
+                // The assumpion is that they are "extra workspace members".
+                match crates[&crate_id].repository {
+                    Some(_) => None,
+                    None => Some(Ok((crate_id, package_path_id))),
+                }
+            })
+            .collect::<Result<BTreeMap<CrateId, String>>>()?;
+
+        Ok(Self {
+            checksum: None,
+            crates,
+            binary_crates,
+            workspace_members,
+            conditions,
+        })
+    }
+
+    // A helper function for locating the unique path in a workspace to a workspace member
+    fn get_package_path_id(
+        package: &cargo_metadata::Package,
+        workspace_root: &Path,
+        workspace_prefix: &Option<String>,
+        package_prefixes: &BTreeMap<String, String>,
+    ) -> Result<String> {
+        // Locate the package's manifest directory
+        let manifest_dir = package
+            .manifest_path
+            .parent()
+            .expect("Every manifest should have a parent")
+            .as_std_path();
+
+        // Compare it with the root of the workspace
+        let package_path_diff = pathdiff::diff_paths(manifest_dir, workspace_root)
+            .expect("Every workspace member's manifest is a child of the workspace root");
+
+        // Ensure the package paths are adjusted in the macros according to the splicing results
+        let package_path = match package_prefixes.get(&package.name) {
+            // Any package prefix should be absolute and therefore always applied
+            Some(prefix) => PathBuf::from(prefix).join(package_path_diff),
+            // If no package prefix is present, attempt to apply the workspace prefix
+            // since workspace members would not have shown up with their own label
+            None => match workspace_prefix {
+                Some(prefix) => PathBuf::from(prefix).join(package_path_diff),
+                None => package_path_diff,
+            },
+        };
+
+        // Sanitize the path for increased consistency
+        let package_path_id = package_path
+            .display()
+            .to_string()
+            .replace('\\', "/")
+            .trim_matches('/')
+            .to_owned();
+
+        Ok(package_path_id)
+    }
+
+    /// Filter a crate's dependencies to only ones with aliases
+    pub fn crate_aliases(
+        &self,
+        crate_id: &CrateId,
+        build: bool,
+        include_dev: bool,
+    ) -> SelectList<&CrateDependency> {
+        let ctx = &self.crates[crate_id];
+        let mut set = SelectList::default();
+
+        // Return a set of aliases for build dependencies
+        // vs normal dependencies when requested.
+        if build {
+            // Note that there may not be build dependencies so no dependencies
+            // will be gathered in this case
+            if let Some(attrs) = &ctx.build_script_attrs {
+                let collection: Vec<(Option<String>, &CrateDependency)> = attrs
+                    .deps
+                    .configurations()
+                    .into_iter()
+                    .flat_map(move |conf| {
+                        attrs
+                            .deps
+                            .get_iter(conf)
+                            .expect("Iterating over known keys should never panic")
+                            .filter(|dep| dep.alias.is_some())
+                            .map(move |dep| (conf.cloned(), dep))
+                    })
+                    .chain(attrs.proc_macro_deps.configurations().into_iter().flat_map(
+                        move |conf| {
+                            attrs
+                                .proc_macro_deps
+                                .get_iter(conf)
+                                .expect("Iterating over known keys should never panic")
+                                .filter(|dep| dep.alias.is_some())
+                                .map(move |dep| (conf.cloned(), dep))
+                        },
+                    ))
+                    .collect();
+
+                for (config, dep) in collection {
+                    set.insert(dep, config);
+                }
+            }
+        } else {
+            let attrs = &ctx.common_attrs;
+            let mut collection: Vec<(Option<String>, &CrateDependency)> =
+                attrs
+                    .deps
+                    .configurations()
+                    .into_iter()
+                    .flat_map(move |conf| {
+                        attrs
+                            .deps
+                            .get_iter(conf)
+                            .expect("Iterating over known keys should never panic")
+                            .filter(|dep| dep.alias.is_some())
+                            .map(move |dep| (conf.cloned(), dep))
+                    })
+                    .chain(attrs.proc_macro_deps.configurations().into_iter().flat_map(
+                        move |conf| {
+                            attrs
+                                .proc_macro_deps
+                                .get_iter(conf)
+                                .expect("Iterating over known keys should never panic")
+                                .filter(|dep| dep.alias.is_some())
+                                .map(move |dep| (conf.cloned(), dep))
+                        },
+                    ))
+                    .collect();
+
+            // Optionally include dev dependencies
+            if include_dev {
+                collection = collection
+                    .into_iter()
+                    .chain(
+                        attrs
+                            .deps_dev
+                            .configurations()
+                            .into_iter()
+                            .flat_map(move |conf| {
+                                attrs
+                                    .deps_dev
+                                    .get_iter(conf)
+                                    .expect("Iterating over known keys should never panic")
+                                    .filter(|dep| dep.alias.is_some())
+                                    .map(move |dep| (conf.cloned(), dep))
+                            }),
+                    )
+                    .chain(
+                        attrs
+                            .proc_macro_deps_dev
+                            .configurations()
+                            .into_iter()
+                            .flat_map(move |conf| {
+                                attrs
+                                    .proc_macro_deps_dev
+                                    .get_iter(conf)
+                                    .expect("Iterating over known keys should never panic")
+                                    .filter(|dep| dep.alias.is_some())
+                                    .map(move |dep| (conf.cloned(), dep))
+                            }),
+                    )
+                    .collect();
+            }
+
+            for (config, dep) in collection {
+                set.insert(dep, config);
+            }
+        }
+
+        set
+    }
+
+    /// Create a set of all direct dependencies of workspace member crates and map them to
+    /// optional alternative names that allow them to be uniquely identified. This typically
+    /// results in a mapping of ([CrateId], [None]) where [None] defaults to using the crate
+    /// name. The next most common would be using ([CrateId], `Some(alias)`) as some projects
+    /// may use aliases in Cargo as a way to differentiate different versions of the same dep.
+    pub fn flat_workspace_member_deps(&self) -> BTreeMap<CrateId, Option<String>> {
+        let workspace_member_dependencies: BTreeSet<CrateDependency> = self
+            .workspace_members
+            .iter()
+            .map(|(id, _)| &self.crates[id])
+            .flat_map(|ctx| {
+                // Build an interator of all dependency CrateIds.
+                // TODO: This expansion is horribly verbose and should be refactored but closures
+                // were not playing nice when I tried it.
+                ctx.common_attrs
+                    .deps
+                    .configurations()
+                    .into_iter()
+                    .flat_map(move |conf| {
+                        ctx.common_attrs
+                            .deps
+                            .get_iter(conf)
+                            .expect("Lookup should be guaranteed")
+                    })
+                    .chain(
+                        ctx.common_attrs
+                            .deps_dev
+                            .configurations()
+                            .into_iter()
+                            .flat_map(move |conf| {
+                                ctx.common_attrs
+                                    .deps_dev
+                                    .get_iter(conf)
+                                    .expect("Lookup should be guaranteed")
+                            }),
+                    )
+                    .chain(
+                        ctx.common_attrs
+                            .proc_macro_deps
+                            .configurations()
+                            .into_iter()
+                            .flat_map(move |conf| {
+                                ctx.common_attrs
+                                    .proc_macro_deps
+                                    .get_iter(conf)
+                                    .expect("Lookup should be guaranteed")
+                            }),
+                    )
+                    .chain(
+                        ctx.common_attrs
+                            .proc_macro_deps_dev
+                            .configurations()
+                            .into_iter()
+                            .flat_map(move |conf| {
+                                ctx.common_attrs
+                                    .proc_macro_deps_dev
+                                    .get_iter(conf)
+                                    .expect("Lookup should be guaranteed")
+                            }),
+                    )
+            })
+            .cloned()
+            .collect();
+
+        // Search for any duplicate workspace member definitions
+        let duplicate_deps: Vec<CrateDependency> = workspace_member_dependencies
+            .iter()
+            .filter(|dep| {
+                workspace_member_dependencies
+                    .iter()
+                    .filter(|check| dep.id.name == check.id.name)
+                    .count()
+                    > 1
+            })
+            .cloned()
+            .collect();
+
+        workspace_member_dependencies
+            .into_iter()
+            .map(|dep| {
+                if duplicate_deps.contains(&dep) {
+                    if let Some(alias) = &dep.alias {
+                        // Check for any duplicate aliases
+                        let aliases = duplicate_deps
+                            .iter()
+                            .filter(|dupe| dupe.id.name == dep.id.name)
+                            .filter(|dupe| dupe.alias.is_some())
+                            .filter(|dupe| dupe.alias == dep.alias);
+
+                        // If there are multiple aliased crates with the same name, the name is updated to
+                        // be `{alias}-{version}` to differentiate them.
+                        if aliases.count() >= 2 {
+                            let rename = format!("{}-{}", &alias, &dep.id.version);
+                            (dep.id, Some(rename))
+                        } else {
+                            (dep.id, Some(alias.clone()))
+                        }
+                    } else {
+                        // Check for all duplicates that match the current dependency and have no alias
+                        let unaliased = duplicate_deps
+                            .iter()
+                            .filter(|dupe| dupe.id.name == dep.id.name)
+                            .filter(|dupe| dupe.alias.is_none());
+
+                        // If there are multiple unaliased crates with the same name, the name is updated to
+                        // be `{name}-{version}` to differentiate them.
+                        if unaliased.count() >= 2 {
+                            let rename = format!("{}-{}", &dep.id.name, &dep.id.version);
+                            (dep.id, Some(rename))
+                        } else {
+                            (dep.id, None)
+                        }
+                    }
+                } else {
+                    (dep.id, dep.alias)
+                }
+            })
+            .collect()
+    }
+
+    /// Produce a list of binary dependencies with optional aliases which prevent duplicate
+    /// targets from being generated.
+    pub fn flat_binary_deps(&self) -> BTreeMap<CrateId, Option<String>> {
+        // Check for any duplicate binary crate names. If one exists provide an alias to differentiate them
+        self.binary_crates
+            .iter()
+            .map(|crate_id| {
+                let dupe_count = self
+                    .binary_crates
+                    .iter()
+                    .filter(|id| crate_id.name == id.name)
+                    .count();
+                // For targets that appear twice (which can happen if one crate aliases a binary dependency)
+                if dupe_count >= 2 {
+                    let rename = format!("{}-{}", crate_id.name, crate_id.version);
+                    (crate_id.clone(), Some(rename))
+                } else {
+                    (crate_id.clone(), None)
+                }
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::config::Config;
+
+    fn mock_context_common() -> Context {
+        let annotations = Annotations::new(
+            crate::test::metadata::common(),
+            crate::test::lockfile::common(),
+            Config::default(),
+        )
+        .unwrap();
+
+        Context::new(annotations).unwrap()
+    }
+
+    fn mock_context_aliases() -> Context {
+        let annotations = Annotations::new(
+            crate::test::metadata::alias(),
+            crate::test::lockfile::alias(),
+            Config::default(),
+        )
+        .unwrap();
+
+        Context::new(annotations).unwrap()
+    }
+
+    #[test]
+    fn flat_workspace_member_deps() {
+        let context = mock_context_common();
+        let workspace_member_deps = context.flat_workspace_member_deps();
+
+        assert_eq!(
+            workspace_member_deps,
+            BTreeMap::from([
+                (
+                    CrateId::new("bitflags".to_owned(), "1.3.2".to_owned()),
+                    None
+                ),
+                (CrateId::new("cfg-if".to_owned(), "1.0.0".to_owned()), None),
+            ])
+        );
+    }
+
+    #[test]
+    fn flat_workspace_member_deps_with_alises() {
+        let context = mock_context_aliases();
+        let workspace_member_deps = context.flat_workspace_member_deps();
+
+        assert_eq!(
+            workspace_member_deps,
+            BTreeMap::from([
+                (
+                    CrateId {
+                        name: "log".to_owned(),
+                        version: "0.3.9".to_owned(),
+                    },
+                    Some("pinned_log".to_owned())
+                ),
+                (
+                    CrateId {
+                        name: "log".to_owned(),
+                        version: "0.4.14".to_owned(),
+                    },
+                    None
+                ),
+                (
+                    CrateId {
+                        name: "names".to_owned(),
+                        version: "0.12.1-dev".to_owned(),
+                    },
+                    Some("pinned_names".to_owned())
+                ),
+                (
+                    CrateId {
+                        name: "names".to_owned(),
+                        version: "0.13.0".to_owned(),
+                    },
+                    None
+                ),
+                (
+                    CrateId {
+                        name: "value-bag".to_owned(),
+                        version: "1.0.0-alpha.7".to_owned(),
+                    },
+                    None
+                ),
+            ])
+        );
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/context/crate_context.rs b/third_party/rules_rust/crate_universe/src/context/crate_context.rs
new file mode 100644
index 0000000..0278ebe
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/context/crate_context.rs
@@ -0,0 +1,838 @@
+//! Crate specific information embedded into [crate::context::Context] objects.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use cargo_metadata::{Node, Package, PackageId};
+use serde::{Deserialize, Serialize};
+
+use crate::config::CrateId;
+use crate::metadata::{CrateAnnotation, Dependency, PairredExtras, SourceAnnotation};
+use crate::utils::sanitize_module_name;
+use crate::utils::starlark::{Glob, SelectList, SelectMap, SelectStringDict, SelectStringList};
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+pub struct CrateDependency {
+    /// The [CrateId] of the dependency
+    pub id: CrateId,
+
+    /// The target name of the dependency. Note this may differ from the
+    /// dependency's package name in cases such as build scripts.
+    pub target: String,
+
+    /// Some dependencies are assigned aliases. This is tracked here
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub alias: Option<String>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+#[serde(default)]
+pub struct TargetAttributes {
+    /// The module name of the crate (notably, not the package name).
+    pub crate_name: String,
+
+    /// The path to the crate's root source file, relative to the manifest.
+    pub crate_root: Option<String>,
+
+    /// A glob pattern of all source files required by the target
+    pub srcs: Glob,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+pub enum Rule {
+    /// `cargo_build_script`
+    BuildScript(TargetAttributes),
+
+    /// `rust_proc_macro`
+    ProcMacro(TargetAttributes),
+
+    /// `rust_library`
+    Library(TargetAttributes),
+
+    /// `rust_binary`
+    Binary(TargetAttributes),
+}
+
+/// A set of attributes common to most `rust_library`, `rust_proc_macro`, and other
+/// [core rules of `rules_rust`](https://bazelbuild.github.io/rules_rust/defs.html).
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+#[serde(default)]
+pub struct CommonAttributes {
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub compile_data: SelectStringList,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub compile_data_glob: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub crate_features: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub data: SelectStringList,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub data_glob: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub deps: SelectList<CrateDependency>,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub extra_deps: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub deps_dev: SelectList<CrateDependency>,
+
+    pub edition: String,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub linker_script: Option<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub proc_macro_deps: SelectList<CrateDependency>,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub extra_proc_macro_deps: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub proc_macro_deps_dev: SelectList<CrateDependency>,
+
+    #[serde(skip_serializing_if = "SelectStringDict::should_skip_serializing")]
+    pub rustc_env: SelectStringDict,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub rustc_env_files: SelectStringList,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub rustc_flags: SelectStringList,
+
+    pub version: String,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+
+impl Default for CommonAttributes {
+    fn default() -> Self {
+        Self {
+            compile_data: Default::default(),
+            // Generated targets include all files in their package by default
+            compile_data_glob: BTreeSet::from(["**".to_owned()]),
+            crate_features: Default::default(),
+            data: Default::default(),
+            data_glob: Default::default(),
+            deps: Default::default(),
+            extra_deps: Default::default(),
+            deps_dev: Default::default(),
+            edition: Default::default(),
+            linker_script: Default::default(),
+            proc_macro_deps: Default::default(),
+            extra_proc_macro_deps: Default::default(),
+            proc_macro_deps_dev: Default::default(),
+            rustc_env: Default::default(),
+            rustc_env_files: Default::default(),
+            rustc_flags: Default::default(),
+            version: Default::default(),
+            tags: Default::default(),
+        }
+    }
+}
+
+// Build script attributes. See
+// https://bazelbuild.github.io/rules_rust/cargo.html#cargo_build_script
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+#[serde(default)]
+pub struct BuildScriptAttributes {
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub compile_data: SelectStringList,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub data: SelectStringList,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub data_glob: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub deps: SelectList<CrateDependency>,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub extra_deps: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectStringDict::should_skip_serializing")]
+    pub build_script_env: SelectStringDict,
+
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    pub extra_proc_macro_deps: BTreeSet<String>,
+
+    #[serde(skip_serializing_if = "SelectList::should_skip_serializing")]
+    pub proc_macro_deps: SelectList<CrateDependency>,
+
+    #[serde(skip_serializing_if = "SelectStringDict::should_skip_serializing")]
+    pub rustc_env: SelectStringDict,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub rustc_flags: SelectStringList,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub rustc_env_files: SelectStringList,
+
+    #[serde(skip_serializing_if = "SelectStringList::should_skip_serializing")]
+    pub tools: SelectStringList,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub links: Option<String>,
+}
+
+impl Default for BuildScriptAttributes {
+    fn default() -> Self {
+        Self {
+            compile_data: Default::default(),
+            data: Default::default(),
+            // Build scripts include all sources by default
+            data_glob: BTreeSet::from(["**".to_owned()]),
+            deps: Default::default(),
+            extra_deps: Default::default(),
+            build_script_env: Default::default(),
+            extra_proc_macro_deps: Default::default(),
+            proc_macro_deps: Default::default(),
+            rustc_env: Default::default(),
+            rustc_flags: Default::default(),
+            rustc_env_files: Default::default(),
+            tools: Default::default(),
+            links: Default::default(),
+        }
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
+#[serde(default)]
+pub struct CrateContext {
+    /// The package name of the current crate
+    pub name: String,
+
+    /// The full version of the current crate
+    pub version: String,
+
+    /// Optional source annotations if they were discoverable in the
+    /// lockfile. Workspace Members will not have source annotations and
+    /// potentially others.
+    pub repository: Option<SourceAnnotation>,
+
+    /// A list of all targets (lib, proc-macro, bin) associated with this package
+    pub targets: Vec<Rule>,
+
+    /// The name of the crate's root library target. This is the target that a dependent
+    /// would get if they were to depend on `{crate_name}`.
+    pub library_target_name: Option<String>,
+
+    /// A set of attributes common to most [Rule] types or target types.
+    pub common_attrs: CommonAttributes,
+
+    /// Optional attributes for build scripts. This field is only populated if
+    /// a build script (`custom-build`) target is defined for the crate.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub build_script_attrs: Option<BuildScriptAttributes>,
+
+    /// The license used by the crate
+    pub license: Option<String>,
+
+    /// Additional text to add to the generated BUILD file.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub additive_build_file_content: Option<String>,
+}
+
+impl CrateContext {
+    pub fn new(
+        annotation: &CrateAnnotation,
+        packages: &BTreeMap<PackageId, Package>,
+        source_annotations: &BTreeMap<PackageId, SourceAnnotation>,
+        extras: &BTreeMap<CrateId, PairredExtras>,
+        include_build_scripts: bool,
+    ) -> Self {
+        let package: &Package = &packages[&annotation.node.id];
+        let current_crate_id = CrateId::new(package.name.clone(), package.version.to_string());
+
+        let new_crate_dep = |dep: Dependency| -> CrateDependency {
+            let pkg = &packages[&dep.package_id];
+
+            // Unfortunately, The package graph and resolve graph of cargo metadata have different representations
+            // for the crate names (resolve graph sanitizes names to match module names) so to get the rest of this
+            // content to align when rendering, the dependency target needs to be explicitly sanitized.
+            let target = sanitize_module_name(&dep.target_name);
+
+            CrateDependency {
+                id: CrateId::new(pkg.name.clone(), pkg.version.to_string()),
+                target,
+                alias: dep.alias,
+            }
+        };
+
+        // Convert the dependencies into renderable strings
+        let deps = annotation.deps.normal_deps.clone().map(new_crate_dep);
+        let deps_dev = annotation.deps.normal_dev_deps.clone().map(new_crate_dep);
+        let proc_macro_deps = annotation.deps.proc_macro_deps.clone().map(new_crate_dep);
+        let proc_macro_deps_dev = annotation
+            .deps
+            .proc_macro_dev_deps
+            .clone()
+            .map(new_crate_dep);
+
+        // Gather all "common" attributes
+        let mut common_attrs = CommonAttributes {
+            crate_features: annotation.node.features.iter().cloned().collect(),
+            deps,
+            deps_dev,
+            edition: package.edition.clone(),
+            proc_macro_deps,
+            proc_macro_deps_dev,
+            version: package.version.to_string(),
+            ..Default::default()
+        };
+
+        let include_build_scripts =
+            Self::crate_includes_build_script(package, extras, include_build_scripts);
+
+        // Iterate over each target and produce a Bazel target for all supported "kinds"
+        let targets = Self::collect_targets(&annotation.node, packages, include_build_scripts);
+
+        // Parse the library crate name from the set of included targets
+        let library_target_name = {
+            let lib_targets: Vec<&TargetAttributes> = targets
+                .iter()
+                .filter_map(|t| match t {
+                    Rule::ProcMacro(attrs) => Some(attrs),
+                    Rule::Library(attrs) => Some(attrs),
+                    _ => None,
+                })
+                .collect();
+
+            // TODO: There should only be at most 1 library target. This case
+            // should be handled in a more intelligent way.
+            assert!(lib_targets.len() <= 1);
+            lib_targets
+                .iter()
+                .last()
+                .map(|attr| attr.crate_name.clone())
+        };
+
+        // Gather any build-script related attributes
+        let build_script_target = targets.iter().find_map(|r| match r {
+            Rule::BuildScript(attr) => Some(attr),
+            _ => None,
+        });
+
+        let build_script_attrs = if let Some(target) = build_script_target {
+            // Track the build script dependency
+            common_attrs.deps.insert(
+                CrateDependency {
+                    id: current_crate_id,
+                    target: target.crate_name.clone(),
+                    alias: None,
+                },
+                None,
+            );
+
+            let build_deps = annotation.deps.build_deps.clone().map(new_crate_dep);
+            let build_proc_macro_deps = annotation
+                .deps
+                .build_proc_macro_deps
+                .clone()
+                .map(new_crate_dep);
+
+            Some(BuildScriptAttributes {
+                deps: build_deps,
+                proc_macro_deps: build_proc_macro_deps,
+                links: package.links.clone(),
+                ..Default::default()
+            })
+        } else {
+            None
+        };
+
+        // Save the repository information for the current crate
+        let repository = source_annotations.get(&package.id).cloned();
+
+        // Identify the license type
+        let license = package.license.clone();
+
+        // Create the crate's context and apply extra settings
+        CrateContext {
+            name: package.name.clone(),
+            version: package.version.to_string(),
+            repository,
+            targets,
+            library_target_name,
+            common_attrs,
+            build_script_attrs,
+            license,
+            additive_build_file_content: None,
+        }
+        .with_overrides(extras)
+    }
+
+    fn with_overrides(mut self, extras: &BTreeMap<CrateId, PairredExtras>) -> Self {
+        let id = CrateId::new(self.name.clone(), self.version.clone());
+
+        // Insert all overrides/extras
+        if let Some(pairred_override) = extras.get(&id) {
+            let crate_extra = &pairred_override.crate_extra;
+
+            // Deps
+            if let Some(extra) = &crate_extra.deps {
+                self.common_attrs.extra_deps = extra.clone();
+            }
+
+            // Proc macro deps
+            if let Some(extra) = &crate_extra.proc_macro_deps {
+                self.common_attrs.extra_proc_macro_deps = extra.clone();
+            }
+
+            // Compile data
+            if let Some(extra) = &crate_extra.compile_data {
+                for data in extra.iter() {
+                    self.common_attrs.compile_data.insert(data.clone(), None);
+                }
+            }
+
+            // Compile data glob
+            if let Some(extra) = &crate_extra.compile_data_glob {
+                self.common_attrs.compile_data_glob.extend(extra.clone());
+            }
+
+            // Crate features
+            if let Some(extra) = &crate_extra.crate_features {
+                for data in extra.iter() {
+                    self.common_attrs.crate_features.insert(data.clone());
+                }
+            }
+
+            // Data
+            if let Some(extra) = &crate_extra.data {
+                for data in extra.iter() {
+                    self.common_attrs.data.insert(data.clone(), None);
+                }
+            }
+
+            // Data glob
+            if let Some(extra) = &crate_extra.data_glob {
+                self.common_attrs.data_glob.extend(extra.clone());
+            }
+
+            // Rustc flags
+            // TODO: SelectList is currently backed by `BTreeSet` which is generally incorrect
+            // for rustc flags. Should SelectList be refactored?
+            if let Some(extra) = &crate_extra.rustc_flags {
+                for data in extra.iter() {
+                    self.common_attrs.rustc_flags.insert(data.clone(), None);
+                }
+            }
+
+            // Rustc env
+            if let Some(extra) = &crate_extra.rustc_env {
+                self.common_attrs.rustc_env.insert(extra.clone(), None);
+            }
+
+            // Rustc env files
+            if let Some(extra) = &crate_extra.rustc_env_files {
+                for data in extra.iter() {
+                    self.common_attrs.rustc_env_files.insert(data.clone(), None);
+                }
+            }
+
+            // Build script Attributes
+            if let Some(attrs) = &mut self.build_script_attrs {
+                // Deps
+                if let Some(extra) = &crate_extra.build_script_deps {
+                    attrs.extra_deps = extra.clone();
+                }
+
+                // Proc macro deps
+                if let Some(extra) = &crate_extra.build_script_proc_macro_deps {
+                    attrs.extra_proc_macro_deps = extra.clone();
+                }
+
+                // Data
+                if let Some(extra) = &crate_extra.build_script_data {
+                    for data in extra {
+                        attrs.data.insert(data.clone(), None);
+                    }
+                }
+
+                // Data glob
+                if let Some(extra) = &crate_extra.build_script_data_glob {
+                    attrs.data_glob.extend(extra.clone());
+                }
+
+                // Rustc env
+                if let Some(extra) = &crate_extra.build_script_rustc_env {
+                    attrs.rustc_env.insert(extra.clone(), None);
+                }
+
+                // Build script env
+                if let Some(extra) = &crate_extra.build_script_env {
+                    attrs.build_script_env.insert(extra.clone(), None);
+                }
+            }
+
+            // Extra build contents
+            self.additive_build_file_content = crate_extra
+                .additive_build_file_content
+                .as_ref()
+                .map(|content| {
+                    // For prettier rendering, dedent the build contents
+                    textwrap::dedent(content)
+                });
+
+            // Git shallow_since
+            if let Some(SourceAnnotation::Git { shallow_since, .. }) = &mut self.repository {
+                *shallow_since = crate_extra.shallow_since.clone()
+            }
+
+            // Patch attributes
+            if let Some(repository) = &mut self.repository {
+                match repository {
+                    SourceAnnotation::Git {
+                        patch_args,
+                        patch_tool,
+                        patches,
+                        ..
+                    } => {
+                        *patch_args = crate_extra.patch_args.clone();
+                        *patch_tool = crate_extra.patch_tool.clone();
+                        *patches = crate_extra.patches.clone();
+                    }
+                    SourceAnnotation::Http {
+                        patch_args,
+                        patch_tool,
+                        patches,
+                        ..
+                    } => {
+                        *patch_args = crate_extra.patch_args.clone();
+                        *patch_tool = crate_extra.patch_tool.clone();
+                        *patches = crate_extra.patches.clone();
+                    }
+                }
+            }
+        }
+
+        self
+    }
+
+    /// Determine whether or not a crate __should__ include a build script
+    /// (build.rs) if it happens to have one.
+    fn crate_includes_build_script(
+        package: &Package,
+        overrides: &BTreeMap<CrateId, PairredExtras>,
+        default_generate_build_script: bool,
+    ) -> bool {
+        // Locate extra settings for the current package.
+        let settings = overrides
+            .iter()
+            .find(|(_, settings)| settings.package_id == package.id);
+
+        // If the crate has extra settings, which explicitly set `gen_build_script`, always use
+        // this value, otherwise, fallback to the provided default.
+        settings
+            .and_then(|(_, settings)| settings.crate_extra.gen_build_script)
+            .unwrap_or(default_generate_build_script)
+    }
+
+    /// Collect all Bazel targets that should be generated for a particular Package
+    fn collect_targets(
+        node: &Node,
+        packages: &BTreeMap<PackageId, Package>,
+        include_build_scripts: bool,
+    ) -> Vec<Rule> {
+        let package = &packages[&node.id];
+
+        let package_root = package
+            .manifest_path
+            .as_std_path()
+            .parent()
+            .expect("Every manifest should have a parent directory");
+
+        package
+            .targets
+            .iter()
+            .flat_map(|target| {
+                target
+                    .kind
+                    .iter()
+                    .filter_map(|kind| {
+                        // Unfortunately, The package graph and resolve graph of cargo metadata have different representations
+                        // for the crate names (resolve graph sanitizes names to match module names) so to get the rest of this
+                        // content to align when rendering, the package target names are always sanitized.
+                        let crate_name = sanitize_module_name(&target.name);
+
+                        // Locate the crate's root source file relative to the package root normalized for unix
+                        let crate_root =
+                            pathdiff::diff_paths(target.src_path.to_string(), package_root).map(
+                                // Normalize the path so that it always renders the same regardless of platform
+                                |root| root.to_string_lossy().replace("\\", "/"),
+                            );
+
+                        // Conditionally check to see if the dependencies is a build-script target
+                        if include_build_scripts && kind == "custom-build" {
+                            return Some(Rule::BuildScript(TargetAttributes {
+                                crate_name,
+                                crate_root,
+                                srcs: Glob::new_rust_srcs(),
+                            }));
+                        }
+
+                        // Check to see if the dependencies is a proc-macro target
+                        if kind == "proc-macro" {
+                            return Some(Rule::ProcMacro(TargetAttributes {
+                                crate_name,
+                                crate_root,
+                                srcs: Glob::new_rust_srcs(),
+                            }));
+                        }
+
+                        // Check to see if the dependencies is a library target
+                        if ["lib", "rlib"].contains(&kind.as_str()) {
+                            return Some(Rule::Library(TargetAttributes {
+                                crate_name,
+                                crate_root,
+                                srcs: Glob::new_rust_srcs(),
+                            }));
+                        }
+
+                        // Check to see if the dependencies is a library target
+                        if kind == "bin" {
+                            return Some(Rule::Binary(TargetAttributes {
+                                crate_name: target.name.clone(),
+                                crate_root,
+                                srcs: Glob::new_rust_srcs(),
+                            }));
+                        }
+
+                        None
+                    })
+                    .collect::<Vec<Rule>>()
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::config::CrateAnnotations;
+    use crate::metadata::Annotations;
+
+    fn common_annotations() -> Annotations {
+        Annotations::new(
+            crate::test::metadata::common(),
+            crate::test::lockfile::common(),
+            crate::config::Config::default(),
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn new_context() {
+        let annotations = common_annotations();
+
+        let crate_annotation = &annotations.metadata.crates[&PackageId {
+            repr: "common 0.1.0 (path+file://{TEMP_DIR}/common)".to_owned(),
+        }];
+
+        let context = CrateContext::new(
+            crate_annotation,
+            &annotations.metadata.packages,
+            &annotations.lockfile.crates,
+            &annotations.pairred_extras,
+            false,
+        );
+
+        assert_eq!(context.name, "common");
+        assert_eq!(
+            context.targets,
+            vec![
+                Rule::Library(TargetAttributes {
+                    crate_name: "common".to_owned(),
+                    crate_root: Some("lib.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                }),
+                Rule::Binary(TargetAttributes {
+                    crate_name: "common-bin".to_owned(),
+                    crate_root: Some("main.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                }),
+            ]
+        );
+    }
+
+    #[test]
+    fn context_with_overrides() {
+        let annotations = common_annotations();
+
+        let package_id = PackageId {
+            repr: "common 0.1.0 (path+file://{TEMP_DIR}/common)".to_owned(),
+        };
+
+        let crate_annotation = &annotations.metadata.crates[&package_id];
+
+        let mut pairred_extras = BTreeMap::new();
+        pairred_extras.insert(
+            CrateId::new("common".to_owned(), "0.1.0".to_owned()),
+            PairredExtras {
+                package_id,
+                crate_extra: CrateAnnotations {
+                    data_glob: Some(BTreeSet::from(["**/data_glob/**".to_owned()])),
+                    ..CrateAnnotations::default()
+                },
+            },
+        );
+
+        let context = CrateContext::new(
+            crate_annotation,
+            &annotations.metadata.packages,
+            &annotations.lockfile.crates,
+            &pairred_extras,
+            false,
+        );
+
+        assert_eq!(context.name, "common");
+        assert_eq!(
+            context.targets,
+            vec![
+                Rule::Library(TargetAttributes {
+                    crate_name: "common".to_owned(),
+                    crate_root: Some("lib.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                }),
+                Rule::Binary(TargetAttributes {
+                    crate_name: "common-bin".to_owned(),
+                    crate_root: Some("main.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                }),
+            ]
+        );
+        assert_eq!(
+            context.common_attrs.data_glob,
+            BTreeSet::from(["**/data_glob/**".to_owned()])
+        );
+    }
+
+    fn build_script_annotations() -> Annotations {
+        Annotations::new(
+            crate::test::metadata::build_scripts(),
+            crate::test::lockfile::build_scripts(),
+            crate::config::Config::default(),
+        )
+        .unwrap()
+    }
+
+    fn crate_type_annotations() -> Annotations {
+        Annotations::new(
+            crate::test::metadata::crate_types(),
+            crate::test::lockfile::crate_types(),
+            crate::config::Config::default(),
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn context_with_build_script() {
+        let annotations = build_script_annotations();
+
+        let package_id = PackageId {
+            repr: "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)"
+                .to_owned(),
+        };
+
+        let crate_annotation = &annotations.metadata.crates[&package_id];
+
+        let context = CrateContext::new(
+            crate_annotation,
+            &annotations.metadata.packages,
+            &annotations.lockfile.crates,
+            &annotations.pairred_extras,
+            true,
+        );
+
+        assert_eq!(context.name, "openssl-sys");
+        assert!(context.build_script_attrs.is_some());
+        assert_eq!(
+            context.targets,
+            vec![
+                Rule::Library(TargetAttributes {
+                    crate_name: "openssl_sys".to_owned(),
+                    crate_root: Some("src/lib.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                }),
+                Rule::BuildScript(TargetAttributes {
+                    crate_name: "build_script_main".to_owned(),
+                    crate_root: Some("build/main.rs".to_owned()),
+                    srcs: Glob::new_rust_srcs(),
+                })
+            ]
+        );
+
+        // Cargo build scripts should include all sources
+        assert!(context.build_script_attrs.unwrap().data_glob.contains("**"));
+    }
+
+    #[test]
+    fn context_disabled_build_script() {
+        let annotations = build_script_annotations();
+
+        let package_id = PackageId {
+            repr: "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)"
+                .to_owned(),
+        };
+
+        let crate_annotation = &annotations.metadata.crates[&package_id];
+
+        let context = CrateContext::new(
+            crate_annotation,
+            &annotations.metadata.packages,
+            &annotations.lockfile.crates,
+            &annotations.pairred_extras,
+            false,
+        );
+
+        assert_eq!(context.name, "openssl-sys");
+        assert!(context.build_script_attrs.is_none());
+        assert_eq!(
+            context.targets,
+            vec![Rule::Library(TargetAttributes {
+                crate_name: "openssl_sys".to_owned(),
+                crate_root: Some("src/lib.rs".to_owned()),
+                srcs: Glob::new_rust_srcs(),
+            })],
+        );
+    }
+
+    #[test]
+    fn context_rlib_crate_type() {
+        let annotations = crate_type_annotations();
+
+        let package_id = PackageId {
+            repr: "sysinfo 0.22.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                .to_owned(),
+        };
+
+        let crate_annotation = &annotations.metadata.crates[&package_id];
+
+        let context = CrateContext::new(
+            crate_annotation,
+            &annotations.metadata.packages,
+            &annotations.lockfile.crates,
+            &annotations.pairred_extras,
+            false,
+        );
+
+        assert_eq!(context.name, "sysinfo");
+        assert!(context.build_script_attrs.is_none());
+        assert_eq!(
+            context.targets,
+            vec![Rule::Library(TargetAttributes {
+                crate_name: "sysinfo".to_owned(),
+                crate_root: Some("src/lib.rs".to_owned()),
+                srcs: Glob::new_rust_srcs(),
+            })],
+        );
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/context/platforms.rs b/third_party/rules_rust/crate_universe/src/context/platforms.rs
new file mode 100644
index 0000000..724dbd0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/context/platforms.rs
@@ -0,0 +1,269 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+
+use anyhow::{anyhow, Context, Result};
+use cfg_expr::targets::{get_builtin_target_by_triple, TargetInfo};
+use cfg_expr::{Expression, Predicate};
+
+use crate::context::CrateContext;
+use crate::utils::starlark::Select;
+
+/// Walk through all dependencies in a [CrateContext] list for all configuration specific
+/// dependencies to produce a mapping of configuration to compatible platform triples.
+pub fn resolve_cfg_platforms(
+    crates: Vec<&CrateContext>,
+    supported_platform_triples: &BTreeSet<String>,
+) -> Result<BTreeMap<String, BTreeSet<String>>> {
+    // Collect all unique configurations from all dependencies into a single set
+    let configurations: BTreeSet<String> = crates
+        .iter()
+        .flat_map(|ctx| {
+            let attr = &ctx.common_attrs;
+            attr.deps
+                .configurations()
+                .into_iter()
+                .chain(attr.deps_dev.configurations().into_iter())
+                .chain(attr.proc_macro_deps.configurations().into_iter())
+                .chain(attr.proc_macro_deps_dev.configurations().into_iter())
+                // Chain the build dependencies if some are defined
+                .chain(if let Some(attr) = &ctx.build_script_attrs {
+                    attr.deps
+                        .configurations()
+                        .into_iter()
+                        .chain(attr.proc_macro_deps.configurations().into_iter())
+                        .collect::<BTreeSet<Option<&String>>>()
+                        .into_iter()
+                } else {
+                    BTreeSet::new().into_iter()
+                })
+                .flatten()
+        })
+        .cloned()
+        .collect();
+
+    // Generate target information for each triple string
+    let target_infos = supported_platform_triples
+        .iter()
+        .map(|t| match get_builtin_target_by_triple(t) {
+            Some(info) => Ok(info),
+            None => Err(anyhow!(
+                "Invalid platform triple in supported platforms: {}",
+                t
+            )),
+        })
+        .collect::<Result<Vec<&'static TargetInfo>>>()?;
+
+    // `cfg-expr` does not understand configurations that are simply platform triples
+    // (`x86_64-unknown-linux-gun` vs `cfg(target = "x86_64-unkonwn-linux-gnu")`). So
+    // in order to parse configurations, the text is renamed for the check but the
+    // original is retained for comaptibility with the manifest.
+    let rename = |cfg: &str| -> String { format!("cfg(target = \"{}\")", cfg) };
+    let original_cfgs: HashMap<String, String> = configurations
+        .iter()
+        .filter(|cfg| !cfg.starts_with("cfg("))
+        .map(|cfg| (rename(cfg), cfg.clone()))
+        .collect();
+
+    configurations
+        .into_iter()
+        // `cfg-expr` requires that the expressions be actual `cfg` expressions. Any time
+        // there's a target triple (which is a valid constraint), convert it to a cfg expression.
+        .map(|cfg| match cfg.starts_with("cfg(") {
+            true => cfg.to_string(),
+            false => rename(&cfg),
+        })
+        // Check the current configuration with against each supported triple
+        .map(|cfg| {
+            let expression = Expression::parse(&cfg)
+                .context(format!("Failed to parse expression: '{}'", cfg))?;
+
+            let triples = target_infos
+                .iter()
+                .filter(|info| {
+                    expression.eval(|p| match p {
+                        Predicate::Target(tp) => tp.matches(**info),
+                        Predicate::KeyValue { key, val } => {
+                            *key == "target" && val == &info.triple.as_str()
+                        }
+                        // For now there is no other kind of matching
+                        _ => false,
+                    })
+                })
+                .map(|info| info.triple.to_string())
+                .collect();
+
+            // Map any renamed configurations back to their original IDs
+            let cfg = match original_cfgs.get(&cfg) {
+                Some(orig) => orig.clone(),
+                None => cfg,
+            };
+
+            Ok((cfg, triples))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod test {
+    use crate::config::CrateId;
+    use crate::context::crate_context::CrateDependency;
+    use crate::context::CommonAttributes;
+    use crate::utils::starlark::SelectList;
+
+    use super::*;
+
+    fn supported_platform_triples() -> BTreeSet<String> {
+        BTreeSet::from([
+            "aarch64-apple-darwin".to_owned(),
+            "aarch64-apple-ios".to_owned(),
+            "aarch64-linux-android".to_owned(),
+            "aarch64-unknown-linux-gnu".to_owned(),
+            "arm-unknown-linux-gnueabi".to_owned(),
+            "armv7-unknown-linux-gnueabi".to_owned(),
+            "i686-apple-darwin".to_owned(),
+            "i686-linux-android".to_owned(),
+            "i686-pc-windows-msvc".to_owned(),
+            "i686-unknown-freebsd".to_owned(),
+            "i686-unknown-linux-gnu".to_owned(),
+            "powerpc-unknown-linux-gnu".to_owned(),
+            "s390x-unknown-linux-gnu".to_owned(),
+            "wasm32-unknown-unknown".to_owned(),
+            "wasm32-wasi".to_owned(),
+            "x86_64-apple-darwin".to_owned(),
+            "x86_64-apple-ios".to_owned(),
+            "x86_64-linux-android".to_owned(),
+            "x86_64-pc-windows-msvc".to_owned(),
+            "x86_64-unknown-freebsd".to_owned(),
+            "x86_64-unknown-linux-gnu".to_owned(),
+        ])
+    }
+
+    #[test]
+    fn resolve_no_targeted() {
+        let mut deps = SelectList::default();
+        deps.insert(
+            CrateDependency {
+                id: CrateId::new("mock_crate_b".to_owned(), "0.1.0".to_owned()),
+                target: "mock_crate_b".to_owned(),
+                alias: None,
+            },
+            None,
+        );
+
+        let context = CrateContext {
+            name: "mock_crate_a".to_owned(),
+            version: "0.1.0".to_owned(),
+            common_attrs: CommonAttributes {
+                deps,
+                ..CommonAttributes::default()
+            },
+            ..CrateContext::default()
+        };
+
+        let configurations =
+            resolve_cfg_platforms(vec![&context], &supported_platform_triples()).unwrap();
+
+        assert_eq!(configurations, BTreeMap::new(),)
+    }
+
+    #[test]
+    fn resolve_targeted() {
+        let configuration = r#"cfg(target = "x86_64-unknown-linux-gnu")"#.to_owned();
+        let mut deps = SelectList::default();
+        deps.insert(
+            CrateDependency {
+                id: CrateId::new("mock_crate_b".to_owned(), "0.1.0".to_owned()),
+                target: "mock_crate_b".to_owned(),
+                alias: None,
+            },
+            Some(configuration.clone()),
+        );
+
+        let context = CrateContext {
+            name: "mock_crate_a".to_owned(),
+            version: "0.1.0".to_owned(),
+            common_attrs: CommonAttributes {
+                deps,
+                ..CommonAttributes::default()
+            },
+            ..CrateContext::default()
+        };
+
+        let configurations =
+            resolve_cfg_platforms(vec![&context], &supported_platform_triples()).unwrap();
+
+        assert_eq!(
+            configurations,
+            BTreeMap::from([(
+                configuration,
+                BTreeSet::from(["x86_64-unknown-linux-gnu".to_owned()])
+            )])
+        );
+    }
+
+    #[test]
+    fn resolve_platforms() {
+        let configuration = r#"x86_64-unknown-linux-gnu"#.to_owned();
+        let mut deps = SelectList::default();
+        deps.insert(
+            CrateDependency {
+                id: CrateId::new("mock_crate_b".to_owned(), "0.1.0".to_owned()),
+                target: "mock_crate_b".to_owned(),
+                alias: None,
+            },
+            Some(configuration.clone()),
+        );
+
+        let context = CrateContext {
+            name: "mock_crate_a".to_owned(),
+            version: "0.1.0".to_owned(),
+            common_attrs: CommonAttributes {
+                deps,
+                ..CommonAttributes::default()
+            },
+            ..CrateContext::default()
+        };
+
+        let configurations =
+            resolve_cfg_platforms(vec![&context], &supported_platform_triples()).unwrap();
+
+        assert_eq!(
+            configurations,
+            BTreeMap::from([(
+                configuration,
+                BTreeSet::from(["x86_64-unknown-linux-gnu".to_owned()])
+            )])
+        );
+    }
+
+    #[test]
+    fn resolve_unsupported_targeted() {
+        let configuration = r#"cfg(target = "x86_64-unknown-unknown")"#.to_owned();
+        let mut deps = SelectList::default();
+        deps.insert(
+            CrateDependency {
+                id: CrateId::new("mock_crate_b".to_owned(), "0.1.0".to_owned()),
+                target: "mock_crate_b".to_owned(),
+                alias: None,
+            },
+            Some(configuration.clone()),
+        );
+
+        let context = CrateContext {
+            name: "mock_crate_a".to_owned(),
+            version: "0.1.0".to_owned(),
+            common_attrs: CommonAttributes {
+                deps,
+                ..CommonAttributes::default()
+            },
+            ..CrateContext::default()
+        };
+
+        let configurations =
+            resolve_cfg_platforms(vec![&context], &supported_platform_triples()).unwrap();
+
+        assert_eq!(
+            configurations,
+            BTreeMap::from([(configuration, BTreeSet::new())])
+        );
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/lib.rs b/third_party/rules_rust/crate_universe/src/lib.rs
new file mode 100644
index 0000000..ae85717
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/lib.rs
@@ -0,0 +1,12 @@
+pub mod cli;
+
+mod config;
+mod context;
+mod lockfile;
+mod metadata;
+mod rendering;
+mod splicing;
+mod utils;
+
+#[cfg(test)]
+mod test;
diff --git a/third_party/rules_rust/crate_universe/src/lockfile.rs b/third_party/rules_rust/crate_universe/src/lockfile.rs
new file mode 100644
index 0000000..91f4832
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/lockfile.rs
@@ -0,0 +1,423 @@
+//! Utility module for interracting with different kinds of lock files
+
+use std::convert::TryFrom;
+use std::ffi::OsStr;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::str::FromStr;
+
+use anyhow::{bail, Context as AnyhowContext, Result};
+use hex::ToHex;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest as Sha2Digest, Sha256};
+
+use crate::config::Config;
+use crate::context::Context;
+use crate::splicing::{SplicingManifest, SplicingMetadata};
+
+#[derive(Debug)]
+pub enum LockfileKind {
+    Auto,
+    Bazel,
+    Cargo,
+}
+
+impl LockfileKind {
+    pub fn detect(path: &Path) -> Result<Self> {
+        let content = fs::read_to_string(path)?;
+
+        if serde_json::from_str::<Context>(&content).is_ok() {
+            return Ok(Self::Bazel);
+        }
+
+        if cargo_lock::Lockfile::from_str(&content).is_ok() {
+            return Ok(Self::Cargo);
+        }
+
+        bail!("Unknown Lockfile kind for {}", path.display())
+    }
+}
+
+impl FromStr for LockfileKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let lower = s.to_lowercase();
+        if lower == "auto" {
+            return Ok(Self::Auto);
+        }
+
+        if lower == "bazel" {
+            return Ok(Self::Bazel);
+        }
+
+        if lower == "cargo" {
+            return Ok(Self::Cargo);
+        }
+
+        bail!("Unknown LockfileKind: '{}'", s)
+    }
+}
+
+pub fn is_cargo_lockfile(path: &Path, kind: &LockfileKind) -> bool {
+    match kind {
+        LockfileKind::Auto => match LockfileKind::detect(path) {
+            Ok(kind) => matches!(kind, LockfileKind::Cargo),
+            Err(_) => false,
+        },
+        LockfileKind::Bazel => false,
+        LockfileKind::Cargo => true,
+    }
+}
+
+pub fn lock_context(
+    mut context: Context,
+    config: &Config,
+    splicing_manifest: &SplicingManifest,
+    cargo_bin: &Path,
+    rustc_bin: &Path,
+) -> Result<Context> {
+    // Ensure there is no existing checksum which could impact the lockfile results
+    context.checksum = None;
+
+    let checksum = Digest::new(&context, config, splicing_manifest, cargo_bin, rustc_bin)
+        .context("Failed to generate context digest")?;
+
+    Ok(Context {
+        checksum: Some(checksum),
+        ..context
+    })
+}
+
+/// Write a [crate::planning::PlannedContext] to disk
+pub fn write_lockfile(lockfile: Context, path: &Path, dry_run: bool) -> Result<()> {
+    let content = serde_json::to_string_pretty(&lockfile)?;
+
+    if dry_run {
+        println!("{:#?}", content);
+    } else {
+        // Ensure the parent directory exists
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::write(path, content + "\n")
+            .context(format!("Failed to write file to disk: {}", path.display()))?;
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct Digest(String);
+
+impl Digest {
+    pub fn new(
+        context: &Context,
+        config: &Config,
+        splicing_manifest: &SplicingManifest,
+        cargo_bin: &Path,
+        rustc_bin: &Path,
+    ) -> Result<Self> {
+        let splicing_metadata = SplicingMetadata::try_from((*splicing_manifest).clone())?;
+        let cargo_version = Self::bin_version(cargo_bin)?;
+        let rustc_version = Self::bin_version(rustc_bin)?;
+        let cargo_bazel_version = env!("CARGO_PKG_VERSION");
+
+        // Ensure the checksum of a digest is not present before computing one
+        Ok(match context.checksum {
+            Some(_) => Self::compute(
+                &Context {
+                    checksum: None,
+                    ..context.clone()
+                },
+                config,
+                &splicing_metadata,
+                cargo_bazel_version,
+                &cargo_version,
+                &rustc_version,
+            ),
+            None => Self::compute(
+                context,
+                config,
+                &splicing_metadata,
+                cargo_bazel_version,
+                &cargo_version,
+                &rustc_version,
+            ),
+        })
+    }
+
+    fn compute(
+        context: &Context,
+        config: &Config,
+        splicing_metadata: &SplicingMetadata,
+        cargo_bazel_version: &str,
+        cargo_version: &str,
+        rustc_version: &str,
+    ) -> Self {
+        // Since this method is private, it should be expected that context is
+        // always None. This then allows us to have this method not return a
+        // Result.
+        debug_assert!(context.checksum.is_none());
+
+        let mut hasher = Sha256::new();
+
+        hasher.update(cargo_bazel_version.as_bytes());
+        hasher.update(b"\0");
+
+        hasher.update(serde_json::to_string(context).unwrap().as_bytes());
+        hasher.update(b"\0");
+
+        hasher.update(serde_json::to_string(config).unwrap().as_bytes());
+        hasher.update(b"\0");
+
+        hasher.update(serde_json::to_string(splicing_metadata).unwrap().as_bytes());
+        hasher.update(b"\0");
+
+        hasher.update(cargo_version.as_bytes());
+        hasher.update(b"\0");
+
+        hasher.update(rustc_version.as_bytes());
+        hasher.update(b"\0");
+
+        Self(hasher.finalize().encode_hex::<String>())
+    }
+
+    fn bin_version(binary: &Path) -> Result<String> {
+        let safe_vars = [OsStr::new("HOMEDRIVE"), OsStr::new("PATHEXT")];
+        let env = std::env::vars_os().filter(|(var, _)| safe_vars.contains(&var.as_os_str()));
+
+        let output = Command::new(binary)
+            .arg("--version")
+            .env_clear()
+            .envs(env)
+            .output()?;
+
+        if !output.status.success() {
+            bail!("Failed to query cargo version")
+        }
+
+        let version = String::from_utf8(output.stdout)?;
+        Ok(version)
+    }
+}
+
+impl PartialEq<str> for Digest {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other
+    }
+}
+
+impl PartialEq<String> for Digest {
+    fn eq(&self, other: &String) -> bool {
+        &self.0 == other
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::config::{CrateAnnotations, CrateId};
+    use crate::splicing::cargo_config::{AdditionalRegistry, CargoConfig, Registry};
+
+    use super::*;
+
+    use std::collections::{BTreeMap, BTreeSet};
+    use std::fs;
+
+    #[test]
+    fn simple_digest() {
+        let context = Context::default();
+        let config = Config::default();
+        let splicing_metadata = SplicingMetadata::default();
+
+        let digest = Digest::compute(
+            &context,
+            &config,
+            &splicing_metadata,
+            "0.1.0",
+            "cargo 1.57.0 (b2e52d7ca 2021-10-21)",
+            "rustc 1.57.0 (f1edd0429 2021-11-29)",
+        );
+
+        assert_eq!(
+            digest,
+            Digest("4c8bc5de2d6d7acc7997ae9870e52bc0f0fcbc2b94076e61162078be6a69cc3b".to_owned())
+        );
+    }
+
+    #[test]
+    fn digest_with_config() {
+        let context = Context::default();
+        let config = Config {
+            generate_build_scripts: false,
+            annotations: BTreeMap::from([(
+                CrateId::new("rustonomicon".to_owned(), "1.0.0".to_owned()),
+                CrateAnnotations {
+                    compile_data_glob: Some(BTreeSet::from(["arts/**".to_owned()])),
+                    ..CrateAnnotations::default()
+                },
+            )]),
+            cargo_config: None,
+            supported_platform_triples: BTreeSet::from([
+                "aarch64-apple-darwin".to_owned(),
+                "aarch64-unknown-linux-gnu".to_owned(),
+                "wasm32-unknown-unknown".to_owned(),
+                "wasm32-wasi".to_owned(),
+                "x86_64-apple-darwin".to_owned(),
+                "x86_64-pc-windows-msvc".to_owned(),
+                "x86_64-unknown-freebsd".to_owned(),
+                "x86_64-unknown-linux-gnu".to_owned(),
+            ]),
+            ..Config::default()
+        };
+
+        let splicing_metadata = SplicingMetadata::default();
+
+        let digest = Digest::compute(
+            &context,
+            &config,
+            &splicing_metadata,
+            "0.1.0",
+            "cargo 1.57.0 (b2e52d7ca 2021-10-21)",
+            "rustc 1.57.0 (f1edd0429 2021-11-29)",
+        );
+
+        assert_eq!(
+            digest,
+            Digest("7a0d2f5fce05c4d433826b5c4748bec7b125b79182de598dc700e893e09077e9".to_owned())
+        );
+    }
+
+    #[test]
+    fn digest_with_splicing_metadata() {
+        let context = Context::default();
+        let config = Config::default();
+        let splicing_metadata = SplicingMetadata {
+            direct_packages: BTreeMap::from([(
+                "rustonomicon".to_owned(),
+                cargo_toml::DependencyDetail {
+                    version: Some("1.0.0".to_owned()),
+                    ..cargo_toml::DependencyDetail::default()
+                },
+            )]),
+            manifests: BTreeMap::new(),
+            cargo_config: None,
+        };
+
+        let digest = Digest::compute(
+            &context,
+            &config,
+            &splicing_metadata,
+            "0.1.0",
+            "cargo 1.57.0 (b2e52d7ca 2021-10-21)",
+            "rustc 1.57.0 (f1edd0429 2021-11-29)",
+        );
+
+        assert_eq!(
+            digest,
+            Digest("fb5d7854dae366d4a9ff135208c28f08c14c2608dd6c5aa1b35b6e677dd53c06".to_owned())
+        );
+    }
+
+    #[test]
+    fn digest_with_cargo_config() {
+        let context = Context::default();
+        let config = Config::default();
+        let cargo_config = CargoConfig {
+            registries: BTreeMap::from([
+                (
+                    "art-crates-remote".to_owned(),
+                    AdditionalRegistry {
+                        index: "https://artprod.mycompany/artifactory/git/cargo-remote.git"
+                            .to_owned(),
+                        token: None,
+                    },
+                ),
+                (
+                    "crates-io".to_owned(),
+                    AdditionalRegistry {
+                        index: "https://github.com/rust-lang/crates.io-index".to_owned(),
+                        token: None,
+                    },
+                ),
+            ]),
+            registry: Registry {
+                default: "art-crates-remote".to_owned(),
+                token: None,
+            },
+            source: BTreeMap::new(),
+        };
+
+        let splicing_metadata = SplicingMetadata {
+            cargo_config: Some(cargo_config),
+            ..SplicingMetadata::default()
+        };
+
+        let digest = Digest::compute(
+            &context,
+            &config,
+            &splicing_metadata,
+            "0.1.0",
+            "cargo 1.57.0 (b2e52d7ca 2021-10-21)",
+            "rustc 1.57.0 (f1edd0429 2021-11-29)",
+        );
+
+        assert_eq!(
+            digest,
+            Digest("2b32833e4265bce03df70dbb9c2b32a78879cc02fbe88a481e3fe4a17812aca9".to_owned())
+        );
+    }
+
+    #[test]
+    fn detect_bazel_lockfile() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let lockfile = temp_dir.as_ref().join("lockfile");
+        fs::write(
+            &lockfile,
+            serde_json::to_string(&crate::context::Context::default()).unwrap(),
+        )
+        .unwrap();
+
+        let kind = LockfileKind::detect(&lockfile).unwrap();
+        assert!(matches!(kind, LockfileKind::Bazel));
+    }
+
+    #[test]
+    fn detect_cargo_lockfile() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let lockfile = temp_dir.as_ref().join("lockfile");
+        fs::write(
+            &lockfile,
+            textwrap::dedent(
+                r#"
+                version = 3
+
+                [[package]]
+                name = "detect"
+                version = "0.1.0"
+                "#,
+            ),
+        )
+        .unwrap();
+
+        let kind = LockfileKind::detect(&lockfile).unwrap();
+        assert!(matches!(kind, LockfileKind::Cargo));
+    }
+
+    #[test]
+    fn detect_invalid_lockfile() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let lockfile = temp_dir.as_ref().join("lockfile");
+        fs::write(&lockfile, "]} invalid {[").unwrap();
+
+        assert!(LockfileKind::detect(&lockfile).is_err());
+    }
+
+    #[test]
+    fn detect_missing_lockfile() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let lockfile = temp_dir.as_ref().join("lockfile");
+        assert!(LockfileKind::detect(&lockfile).is_err());
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/main.rs b/third_party/rules_rust/crate_universe/src/main.rs
new file mode 100644
index 0000000..0a79db4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/main.rs
@@ -0,0 +1,15 @@
+//! The `cargo->bazel` binary's entrypoint
+
+use cargo_bazel::cli;
+
+fn main() -> cli::Result<()> {
+    // Parse arguments
+    let opt = cli::parse_args();
+
+    match opt {
+        cli::Options::Generate(opt) => cli::generate(opt),
+        cli::Options::Splice(opt) => cli::splice(opt),
+        cli::Options::Query(opt) => cli::query(opt),
+        cli::Options::Vendor(opt) => cli::vendor(opt),
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/metadata.rs b/third_party/rules_rust/crate_universe/src/metadata.rs
new file mode 100644
index 0000000..0e48676
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/metadata.rs
@@ -0,0 +1,241 @@
+//! Tools for gathering various kinds of metadata (Cargo.lock, Cargo metadata, Crate Index info).
+
+mod dependency;
+mod metadata_annotation;
+
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::{bail, Context, Result};
+use cargo_lock::Lockfile as CargoLockfile;
+use cargo_metadata::{Metadata as CargoMetadata, MetadataCommand};
+
+pub use self::dependency::*;
+pub use self::metadata_annotation::*;
+
+// TODO: This should also return a set of [crate-index::IndexConfig]s for packages in metadata.packages
+/// A Trait for generating metadata (`cargo metadata` output and a lock file) from a Cargo manifest.
+pub trait MetadataGenerator {
+    fn generate<T: AsRef<Path>>(&self, manifest_path: T) -> Result<(CargoMetadata, CargoLockfile)>;
+}
+
+/// Generates Cargo metadata and a lockfile from a provided manifest.
+pub struct Generator {
+    /// The path to a `cargo` binary
+    cargo_bin: PathBuf,
+
+    /// The path to a `rustc` binary
+    rustc_bin: PathBuf,
+}
+
+impl Generator {
+    pub fn new() -> Self {
+        Generator {
+            cargo_bin: PathBuf::from(env::var("CARGO").unwrap_or_else(|_| "cargo".to_string())),
+            rustc_bin: PathBuf::from(env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string())),
+        }
+    }
+
+    pub fn with_cargo(mut self, cargo_bin: PathBuf) -> Self {
+        self.cargo_bin = cargo_bin;
+        self
+    }
+
+    pub fn with_rustc(mut self, rustc_bin: PathBuf) -> Self {
+        self.rustc_bin = rustc_bin;
+        self
+    }
+}
+
+impl MetadataGenerator for Generator {
+    fn generate<T: AsRef<Path>>(&self, manifest_path: T) -> Result<(CargoMetadata, CargoLockfile)> {
+        let manifest_dir = manifest_path
+            .as_ref()
+            .parent()
+            .expect("The manifest should have a parent directory");
+        let lockfile = {
+            let lock_path = manifest_dir.join("Cargo.lock");
+            if !lock_path.exists() {
+                bail!("No `Cargo.lock` file was found with the given manifest")
+            }
+            cargo_lock::Lockfile::load(lock_path)?
+        };
+
+        let metadata = MetadataCommand::new()
+            .cargo_path(&self.cargo_bin)
+            .current_dir(manifest_dir)
+            .manifest_path(manifest_path.as_ref())
+            .other_options(["--locked".to_owned()])
+            .exec()?;
+
+        Ok((metadata, lockfile))
+    }
+}
+
+pub struct LockGenerator {
+    /// The path to a `cargo` binary
+    cargo_bin: PathBuf,
+
+    /// The path to a `rustc` binary
+    rustc_bin: PathBuf,
+}
+
+impl LockGenerator {
+    pub fn new(cargo_bin: PathBuf, rustc_bin: PathBuf) -> Self {
+        Self {
+            cargo_bin,
+            rustc_bin,
+        }
+    }
+
+    pub fn generate(
+        &self,
+        manifest_path: &Path,
+        existing_lock: &Option<PathBuf>,
+    ) -> Result<cargo_lock::Lockfile> {
+        let manifest_dir = manifest_path.parent().unwrap();
+        let generated_lockfile_path = manifest_dir.join("Cargo.lock");
+
+        let output = if let Some(lock) = existing_lock {
+            if !lock.exists() {
+                bail!(
+                    "An existing lockfile path was provided but a file at '{}' does not exist",
+                    lock.display()
+                )
+            }
+
+            // Install the file into the target location
+            if generated_lockfile_path.exists() {
+                fs::remove_file(&generated_lockfile_path)?;
+            }
+            fs::copy(&lock, &generated_lockfile_path)?;
+
+            // Ensure the Cargo cache is up to date to simulate the behavior
+            // of having just generated a new one
+            Command::new(&self.cargo_bin)
+                // Cargo detects config files based on `pwd` when running so
+                // to ensure user provided Cargo config files are used, it's
+                // critical to set the working directory to the manifest dir.
+                .current_dir(manifest_dir)
+                .arg("fetch")
+                .arg("--locked")
+                .arg("--manifest-path")
+                .arg(manifest_path)
+                .env("RUSTC", &self.rustc_bin)
+                .output()
+                .context(format!(
+                    "Error running cargo to fetch crates '{}'",
+                    manifest_path.display()
+                ))?
+        } else {
+            // Simply invoke `cargo generate-lockfile`
+            Command::new(&self.cargo_bin)
+                // Cargo detects config files based on `pwd` when running so
+                // to ensure user provided Cargo config files are used, it's
+                // critical to set the working directory to the manifest dir.
+                .current_dir(manifest_dir)
+                .arg("generate-lockfile")
+                .arg("--manifest-path")
+                .arg(manifest_path)
+                .env("RUSTC", &self.rustc_bin)
+                .output()
+                .context(format!(
+                    "Error running cargo to generate lockfile '{}'",
+                    manifest_path.display()
+                ))?
+        };
+
+        if !output.status.success() {
+            eprintln!("{}", String::from_utf8_lossy(&output.stdout));
+            eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+            bail!(format!("Failed to generate lockfile: {}", output.status))
+        }
+
+        cargo_lock::Lockfile::load(&generated_lockfile_path).context(format!(
+            "Failed to load lockfile: {}",
+            generated_lockfile_path.display()
+        ))
+    }
+}
+
+/// A generator which runs `cargo vendor` on a given manifest
+pub struct VendorGenerator {
+    /// The path to a `cargo` binary
+    cargo_bin: PathBuf,
+
+    /// The path to a `rustc` binary
+    rustc_bin: PathBuf,
+}
+
+impl VendorGenerator {
+    pub fn new(cargo_bin: PathBuf, rustc_bin: PathBuf) -> Self {
+        Self {
+            cargo_bin,
+            rustc_bin,
+        }
+    }
+
+    pub fn generate(&self, manifest_path: &Path, output_dir: &Path) -> Result<()> {
+        let manifest_dir = manifest_path.parent().unwrap();
+
+        // Simply invoke `cargo generate-lockfile`
+        let output = Command::new(&self.cargo_bin)
+            // Cargo detects config files based on `pwd` when running so
+            // to ensure user provided Cargo config files are used, it's
+            // critical to set the working directory to the manifest dir.
+            .current_dir(manifest_dir)
+            .arg("vendor")
+            .arg("--manifest-path")
+            .arg(manifest_path)
+            .arg("--locked")
+            .arg("--versioned-dirs")
+            .arg(output_dir)
+            .env("RUSTC", &self.rustc_bin)
+            .output()
+            .with_context(|| {
+                format!(
+                    "Error running cargo to vendor sources for manifest '{}'",
+                    manifest_path.display()
+                )
+            })?;
+
+        if !output.status.success() {
+            eprintln!("{}", String::from_utf8_lossy(&output.stdout));
+            eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+            bail!(format!("Failed to vendor sources with: {}", output.status))
+        }
+
+        Ok(())
+    }
+}
+
+/// A helper function for writing Cargo metadata to a file.
+pub fn write_metadata(path: &Path, metadata: &cargo_metadata::Metadata) -> Result<()> {
+    let content =
+        serde_json::to_string_pretty(metadata).context("Failed to serialize Cargo Metadata")?;
+
+    fs::write(path, content).context("Failed to write metadata to disk")
+}
+
+/// A helper function for deserializing Cargo metadata and lockfiles
+pub fn load_metadata(
+    metadata_path: &Path,
+    lockfile_path: Option<&Path>,
+) -> Result<(cargo_metadata::Metadata, cargo_lock::Lockfile)> {
+    let content = fs::read_to_string(metadata_path)
+        .with_context(|| format!("Failed to load Cargo Metadata: {}", metadata_path.display()))?;
+
+    let metadata =
+        serde_json::from_str(&content).context("Unable to deserialize Cargo metadata")?;
+
+    let lockfile_path = lockfile_path
+        .map(PathBuf::from)
+        .unwrap_or_else(|| metadata_path.parent().unwrap().join("Cargo.lock"));
+
+    let lockfile = cargo_lock::Lockfile::load(&lockfile_path)
+        .with_context(|| format!("Failed to load lockfile: {}", lockfile_path.display()))?;
+
+    Ok((metadata, lockfile))
+}
diff --git a/third_party/rules_rust/crate_universe/src/metadata/dependency.rs b/third_party/rules_rust/crate_universe/src/metadata/dependency.rs
new file mode 100644
index 0000000..105e4fe
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/metadata/dependency.rs
@@ -0,0 +1,363 @@
+///! Gathering dependencies is the largest part of annotating.
+use cargo_metadata::{Metadata as CargoMetadata, Node, NodeDep, Package, PackageId};
+use serde::{Deserialize, Serialize};
+
+use crate::utils::sanitize_module_name;
+use crate::utils::starlark::{Select, SelectList};
+
+/// A representation of a crate dependency
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct Dependency {
+    /// The PackageId of the target
+    pub package_id: PackageId,
+
+    /// The library target name of the dependency.
+    pub target_name: String,
+
+    /// The alias for the dependency from the perspective of the current package
+    pub alias: Option<String>,
+}
+
+/// A collection of [Dependency]s sorted by dependency kind.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct DependencySet {
+    pub normal_deps: SelectList<Dependency>,
+    pub normal_dev_deps: SelectList<Dependency>,
+    pub proc_macro_deps: SelectList<Dependency>,
+    pub proc_macro_dev_deps: SelectList<Dependency>,
+    pub build_deps: SelectList<Dependency>,
+    pub build_proc_macro_deps: SelectList<Dependency>,
+}
+
+impl DependencySet {
+    /// Collect all dependencies for a given node in the resolve graph.
+    pub fn new_for_node(node: &Node, metadata: &CargoMetadata) -> Self {
+        let (normal_dev_deps, normal_deps) = {
+            let (dev, normal) = node
+                .deps
+                .iter()
+                // Do not track workspace members as dependencies. Users are expected to maintain those connections
+                .filter(|dep| !is_workspace_member(dep, metadata))
+                .filter(|dep| is_lib_package(&metadata[&dep.pkg]))
+                .filter(|dep| is_normal_dependency(dep) || is_dev_dependency(dep))
+                .partition(|dep| is_dev_dependency(dep));
+
+            (
+                collect_deps_selectable(dev, metadata),
+                collect_deps_selectable(normal, metadata),
+            )
+        };
+
+        let (proc_macro_dev_deps, proc_macro_deps) = {
+            let (dev, normal) = node
+                .deps
+                .iter()
+                // Do not track workspace members as dependencies. Users are expected to maintain those connections
+                .filter(|dep| !is_workspace_member(dep, metadata))
+                .filter(|dep| is_proc_macro_package(&metadata[&dep.pkg]))
+                .filter(|dep| !is_build_dependency(dep))
+                .partition(|dep| is_dev_dependency(dep));
+
+            (
+                collect_deps_selectable(dev, metadata),
+                collect_deps_selectable(normal, metadata),
+            )
+        };
+
+        let (build_proc_macro_deps, mut build_deps) = {
+            let (proc_macro, normal) = node
+                .deps
+                .iter()
+                // Do not track workspace members as dependencies. Users are expected to maintain those connections
+                .filter(|dep| !is_workspace_member(dep, metadata))
+                .filter(|dep| is_build_dependency(dep))
+                .filter(|dep| !is_dev_dependency(dep))
+                .partition(|dep| is_proc_macro_package(&metadata[&dep.pkg]));
+
+            (
+                collect_deps_selectable(proc_macro, metadata),
+                collect_deps_selectable(normal, metadata),
+            )
+        };
+
+        // `*-sys` packages follow slightly different rules than other dependencies. These
+        // packages seem to provide some environment variables required to build the top level
+        // package and are expected to be avialable to other build scripts. If a target depends
+        // on a `*-sys` crate for itself, so would it's build script. Hopefully this is correct.
+        // https://doc.rust-lang.org/cargo/reference/build-scripts.html#the-links-manifest-key
+        // https://doc.rust-lang.org/cargo/reference/build-scripts.html#-sys-packages
+        let sys_name = format!("{}-sys", &metadata[&node.id].name);
+        normal_deps.configurations().into_iter().for_each(|config| {
+            normal_deps
+                .get_iter(config)
+                // Iterating over known key should be safe
+                .unwrap()
+                // Add any normal dependency to build dependencies that are associated `*-sys` crates
+                .for_each(|dep| {
+                    let dep_pkg_name = &metadata[&dep.package_id].name;
+                    if *dep_pkg_name == sys_name {
+                        build_deps.insert(dep.clone(), config.cloned())
+                    }
+                });
+        });
+
+        Self {
+            normal_deps,
+            normal_dev_deps,
+            proc_macro_deps,
+            proc_macro_dev_deps,
+            build_deps,
+            build_proc_macro_deps,
+        }
+    }
+}
+
+fn collect_deps_selectable(
+    deps: Vec<&NodeDep>,
+    metadata: &cargo_metadata::Metadata,
+) -> SelectList<Dependency> {
+    let mut selectable = SelectList::default();
+
+    for dep in deps.into_iter() {
+        let dep_pkg = &metadata[&dep.pkg];
+        let target_name = get_library_target_name(dep_pkg, &dep.name);
+        let alias = get_target_alias(&dep.name, dep_pkg);
+
+        for kind_info in &dep.dep_kinds {
+            selectable.insert(
+                Dependency {
+                    package_id: dep.pkg.clone(),
+                    target_name: target_name.clone(),
+                    alias: alias.clone(),
+                },
+                kind_info
+                    .target
+                    .as_ref()
+                    .map(|platform| platform.to_string()),
+            );
+        }
+    }
+
+    selectable
+}
+
+fn is_lib_package(package: &Package) -> bool {
+    package.targets.iter().any(|target| {
+        target
+            .crate_types
+            .iter()
+            .any(|t| ["lib", "rlib"].contains(&t.as_str()))
+    })
+}
+
+fn is_proc_macro_package(package: &Package) -> bool {
+    package
+        .targets
+        .iter()
+        .any(|target| target.crate_types.iter().any(|t| t == "proc-macro"))
+}
+
+fn is_dev_dependency(node_dep: &NodeDep) -> bool {
+    let is_normal_dep = is_normal_dependency(node_dep);
+    let is_dev_dep = node_dep
+        .dep_kinds
+        .iter()
+        .any(|k| matches!(k.kind, cargo_metadata::DependencyKind::Development));
+
+    // In the event that a dependency is listed as both a dev and normal dependency,
+    // it's only considered a dev dependency if it's __not__ a normal dependency.
+    !is_normal_dep && is_dev_dep
+}
+
+fn is_build_dependency(node_dep: &NodeDep) -> bool {
+    node_dep
+        .dep_kinds
+        .iter()
+        .any(|k| matches!(k.kind, cargo_metadata::DependencyKind::Build))
+}
+
+fn is_normal_dependency(node_dep: &NodeDep) -> bool {
+    node_dep
+        .dep_kinds
+        .iter()
+        .any(|k| matches!(k.kind, cargo_metadata::DependencyKind::Normal))
+}
+
+fn is_workspace_member(node_dep: &NodeDep, metadata: &CargoMetadata) -> bool {
+    metadata
+        .workspace_members
+        .iter()
+        .any(|id| id == &node_dep.pkg)
+}
+
+fn get_library_target_name(package: &Package, potential_name: &str) -> String {
+    // If the potential name is not an alias in a dependent's package, a target's name
+    // should match which means we already know what the target library name is.
+    if package.targets.iter().any(|t| t.name == potential_name) {
+        return potential_name.to_string();
+    }
+
+    // Locate any library type targets
+    let lib_targets: Vec<&cargo_metadata::Target> = package
+        .targets
+        .iter()
+        .filter(|t| t.kind.iter().any(|k| k == "lib" || k == "proc-macro"))
+        .collect();
+
+    // Only one target should be found
+    assert_eq!(lib_targets.len(), 1);
+
+    let target = lib_targets.into_iter().last().unwrap();
+    target.name.clone()
+}
+
+/// The resolve graph (resolve.nodes[#].deps[#].name) of Cargo metadata uses module names
+/// for targets where packages (packages[#].targets[#].name) uses crate names. In order to
+/// determine whether or not a dependency is aliased, we compare it with all available targets
+/// on it's package. Note that target names are not guaranteed to be module names where Node
+/// dependnecies are, so we need to do a conversion to check for this
+fn get_target_alias(target_name: &str, package: &Package) -> Option<String> {
+    match package
+        .targets
+        .iter()
+        .all(|t| sanitize_module_name(&t.name) != target_name)
+    {
+        true => Some(target_name.to_string()),
+        false => None,
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::BTreeSet;
+
+    use super::*;
+
+    use crate::test::*;
+
+    /// Locate the [cargo_metadata::Node] for the crate matching the given name
+    fn find_metadata_node<'a>(
+        name: &str,
+        metadata: &'a cargo_metadata::Metadata,
+    ) -> &'a cargo_metadata::Node {
+        metadata
+            .resolve
+            .as_ref()
+            .unwrap()
+            .nodes
+            .iter()
+            .find(|node| {
+                let pkg = &metadata[&node.id];
+                pkg.name == name
+            })
+            .unwrap()
+    }
+
+    #[test]
+    fn sys_dependencies() {
+        let metadata = metadata::build_scripts();
+
+        let openssl_node = find_metadata_node("openssl", &metadata);
+
+        let dependencies = DependencySet::new_for_node(openssl_node, &metadata);
+
+        let sys_crate = dependencies
+            .normal_deps
+            .get_iter(None)
+            .unwrap()
+            .find(|dep| {
+                let pkg = &metadata[&dep.package_id];
+                pkg.name == "openssl-sys"
+            });
+
+        // sys crates like `openssl-sys` should always be dependencies of any
+        // crate which matches it's name minus the `-sys` suffix
+        assert!(sys_crate.is_some());
+    }
+
+    #[test]
+    fn tracked_aliases() {
+        let metadata = metadata::alias();
+
+        let aliases_node = find_metadata_node("aliases", &metadata);
+        let dependencies = DependencySet::new_for_node(aliases_node, &metadata);
+
+        let aliases: Vec<&Dependency> = dependencies
+            .normal_deps
+            .get_iter(None)
+            .unwrap()
+            .filter(|dep| dep.alias.is_some())
+            .collect();
+
+        assert_eq!(aliases.len(), 2);
+
+        let expected: BTreeSet<String> = aliases
+            .into_iter()
+            .map(|dep| dep.alias.as_ref().unwrap().clone())
+            .collect();
+
+        assert_eq!(
+            expected,
+            BTreeSet::from(["pinned_log".to_owned(), "pinned_names".to_owned()])
+        );
+    }
+
+    #[test]
+    fn matched_rlib() {
+        let metadata = metadata::crate_types();
+
+        let node = find_metadata_node("crate-types", &metadata);
+        let dependencies = DependencySet::new_for_node(node, &metadata);
+
+        let rlib_deps: Vec<&Dependency> = dependencies
+            .normal_deps
+            .get_iter(None)
+            .unwrap()
+            .filter(|dep| {
+                let pkg = &metadata[&dep.package_id];
+                pkg.targets
+                    .iter()
+                    .any(|t| t.crate_types.contains(&"rlib".to_owned()))
+            })
+            .collect();
+
+        // Currently the only expected __explicitly__ "rlib" target in this metadata is `sysinfo`.
+        assert_eq!(rlib_deps.len(), 1);
+
+        let sysinfo_dep = rlib_deps.iter().last().unwrap();
+        assert_eq!(sysinfo_dep.target_name, "sysinfo");
+    }
+
+    #[test]
+    fn multiple_dep_kinds() {
+        let metadata = metadata::multi_cfg_dep();
+
+        let node = find_metadata_node("cpufeatures", &metadata);
+        let dependencies = DependencySet::new_for_node(node, &metadata);
+
+        let libc_cfgs: Vec<Option<String>> = dependencies
+            .normal_deps
+            .configurations()
+            .into_iter()
+            .flat_map(|conf| {
+                dependencies
+                    .normal_deps
+                    .get_iter(conf)
+                    .expect("Iterating over known keys should never panic")
+                    .filter(|dep| dep.target_name == "libc")
+                    .map(move |_| conf.cloned())
+            })
+            .collect();
+
+        assert_eq!(libc_cfgs.len(), 2);
+
+        let cfg_strs: BTreeSet<String> = libc_cfgs.into_iter().flatten().collect();
+        assert_eq!(
+            cfg_strs,
+            BTreeSet::from([
+                "aarch64-apple-darwin".to_owned(),
+                "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))".to_owned(),
+            ])
+        );
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/metadata/metadata_annotation.rs b/third_party/rules_rust/crate_universe/src/metadata/metadata_annotation.rs
new file mode 100644
index 0000000..be4cb7f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/metadata/metadata_annotation.rs
@@ -0,0 +1,555 @@
+//! Collect and store information from Cargo metadata specific to Bazel's needs
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::convert::TryFrom;
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use cargo_metadata::{Node, Package, PackageId};
+use hex::ToHex;
+use serde::{Deserialize, Serialize};
+
+use crate::config::{Commitish, Config, CrateAnnotations, CrateId};
+use crate::metadata::dependency::DependencySet;
+use crate::splicing::{SourceInfo, WorkspaceMetadata};
+
+pub type CargoMetadata = cargo_metadata::Metadata;
+pub type CargoLockfile = cargo_lock::Lockfile;
+
+/// Additional information about a crate relative to other crates in a dependency graph.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CrateAnnotation {
+    /// The crate's node in the Cargo "resolve" graph.
+    pub node: Node,
+
+    /// The crate's sorted dependencies.
+    pub deps: DependencySet,
+}
+
+/// Additional information about a Cargo workspace's metadata.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct MetadataAnnotation {
+    /// All packages found within the Cargo metadata
+    pub packages: BTreeMap<PackageId, Package>,
+
+    /// All [CrateAnnotation]s for all packages
+    pub crates: BTreeMap<PackageId, CrateAnnotation>,
+
+    /// All packages that are workspace members
+    pub workspace_members: BTreeSet<PackageId>,
+
+    /// The path to the directory containing the Cargo workspace that produced the metadata.
+    pub workspace_root: PathBuf,
+
+    /// Information on the Cargo workspace.
+    pub workspace_metadata: WorkspaceMetadata,
+}
+
+impl MetadataAnnotation {
+    pub fn new(metadata: CargoMetadata) -> MetadataAnnotation {
+        // UNWRAP: The workspace metadata should be written by a controlled process. This should not return a result
+        let workspace_metadata = find_workspace_metadata(&metadata).unwrap_or_default();
+
+        let resolve = metadata
+            .resolve
+            .as_ref()
+            .expect("The metadata provided requires a resolve graph")
+            .clone();
+
+        let is_node_workspace_member = |node: &Node, metadata: &CargoMetadata| -> bool {
+            metadata.workspace_members.iter().any(|pkg| pkg == &node.id)
+        };
+
+        let workspace_members: BTreeSet<PackageId> = resolve
+            .nodes
+            .iter()
+            .filter(|node| is_node_workspace_member(node, &metadata))
+            .map(|node| node.id.clone())
+            .collect();
+
+        let crates = resolve
+            .nodes
+            .iter()
+            .map(|node| {
+                (
+                    node.id.clone(),
+                    Self::annotate_crate(node.clone(), &metadata),
+                )
+            })
+            .collect();
+
+        let packages = metadata
+            .packages
+            .into_iter()
+            .map(|pkg| (pkg.id.clone(), pkg))
+            .collect();
+
+        MetadataAnnotation {
+            packages,
+            crates,
+            workspace_members,
+            workspace_root: PathBuf::from(metadata.workspace_root.as_std_path()),
+            workspace_metadata,
+        }
+    }
+
+    fn annotate_crate(node: Node, metadata: &CargoMetadata) -> CrateAnnotation {
+        // Gather all dependencies
+        let deps = DependencySet::new_for_node(&node, metadata);
+
+        CrateAnnotation { node, deps }
+    }
+}
+
+/// Additional information about how and where to acquire a crate's source code from.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum SourceAnnotation {
+    Git {
+        /// The Git url where to clone the source from.
+        remote: String,
+
+        /// The revision information for the git repository. This is used for
+        /// [git_repository::commit](https://docs.bazel.build/versions/main/repo/git.html#git_repository-commit),
+        /// [git_repository::tag](https://docs.bazel.build/versions/main/repo/git.html#git_repository-tag), or
+        /// [git_repository::branch](https://docs.bazel.build/versions/main/repo/git.html#git_repository-branch).
+        commitish: Commitish,
+
+        /// See [git_repository::shallow_since](https://docs.bazel.build/versions/main/repo/git.html#git_repository-shallow_since)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        shallow_since: Option<String>,
+
+        /// See [git_repository::strip_prefix](https://docs.bazel.build/versions/main/repo/git.html#git_repository-strip_prefix)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        strip_prefix: Option<String>,
+
+        /// See [git_repository::patch_args](https://docs.bazel.build/versions/main/repo/git.html#git_repository-patch_args)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patch_args: Option<Vec<String>>,
+
+        /// See [git_repository::patch_tool](https://docs.bazel.build/versions/main/repo/git.html#git_repository-patch_tool)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patch_tool: Option<String>,
+
+        /// See [git_repository::patches](https://docs.bazel.build/versions/main/repo/git.html#git_repository-patches)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patches: Option<BTreeSet<String>>,
+    },
+    Http {
+        /// See [http_archive::url](https://docs.bazel.build/versions/main/repo/http.html#http_archive-url)
+        url: String,
+
+        /// See [http_archive::sha256](https://docs.bazel.build/versions/main/repo/http.html#http_archive-sha256)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        sha256: Option<String>,
+
+        /// See [http_archive::patch_args](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_args)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patch_args: Option<Vec<String>>,
+
+        /// See [http_archive::patch_tool](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_tool)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patch_tool: Option<String>,
+
+        /// See [http_archive::patches](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patches)
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        patches: Option<BTreeSet<String>>,
+    },
+}
+
+/// TODO
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+pub struct LockfileAnnotation {
+    /// TODO
+    pub crates: BTreeMap<PackageId, SourceAnnotation>,
+}
+
+impl LockfileAnnotation {
+    pub fn new(lockfile: CargoLockfile, metadata: &CargoMetadata) -> Result<Self> {
+        let workspace_metadata = find_workspace_metadata(metadata).unwrap_or_default();
+
+        let nodes: Vec<&Node> = metadata
+            .resolve
+            .as_ref()
+            .expect("Metadata is expected to have a resolve graph")
+            .nodes
+            .iter()
+            .filter(|node| !is_workspace_member(&node.id, metadata))
+            .collect();
+
+        // Produce source annotations for each crate in the resolve graph
+        let crates = nodes
+            .iter()
+            .map(|node| {
+                Ok((
+                    node.id.clone(),
+                    Self::collect_source_annotations(
+                        node,
+                        metadata,
+                        &lockfile,
+                        &workspace_metadata,
+                    )?,
+                ))
+            })
+            .collect::<Result<BTreeMap<PackageId, SourceAnnotation>>>()?;
+
+        Ok(Self { crates })
+    }
+
+    /// Resolve all URLs and checksum-like data for each package
+    fn collect_source_annotations(
+        node: &Node,
+        metadata: &CargoMetadata,
+        lockfile: &CargoLockfile,
+        workspace_metadata: &WorkspaceMetadata,
+    ) -> Result<SourceAnnotation> {
+        let pkg = &metadata[&node.id];
+
+        // Locate the matching lock package for the current crate
+        let lock_pkg = match cargo_meta_pkg_to_locked_pkg(pkg, &lockfile.packages) {
+            Some(lock_pkg) => lock_pkg,
+            None => bail!(
+                "Could not find lockfile entry matching metadata package '{}'",
+                pkg.name
+            ),
+        };
+
+        // Check for spliced information about a crate's network source.
+        let spliced_source_info = Self::find_source_annotation(lock_pkg, workspace_metadata);
+
+        // Parse it's source info. The check above should prevent a panic
+        let source = match lock_pkg.source.as_ref() {
+            Some(source) => source,
+            None => match spliced_source_info {
+                Some(info) => {
+                    return Ok(SourceAnnotation::Http {
+                        url: info.url,
+                        sha256: Some(info.sha256),
+                        patch_args: None,
+                        patch_tool: None,
+                        patches: None,
+                    })
+                }
+                None => bail!(
+                    "The package '{:?} {:?}' has no source info so no annotation can be made",
+                    lock_pkg.name,
+                    lock_pkg.version
+                ),
+            },
+        };
+
+        // Handle any git repositories
+        if let Some(git_ref) = source.git_reference() {
+            let strip_prefix = Self::extract_git_strip_prefix(pkg)?;
+
+            return Ok(SourceAnnotation::Git {
+                remote: source.url().to_string(),
+                commitish: Commitish::from(git_ref.clone()),
+                shallow_since: None,
+                strip_prefix,
+                patch_args: None,
+                patch_tool: None,
+                patches: None,
+            });
+        }
+
+        // One of the last things that should be checked is the spliced source information as
+        // other sources may more accurately represent where a crate should be downloaded.
+        if let Some(info) = spliced_source_info {
+            return Ok(SourceAnnotation::Http {
+                url: info.url,
+                sha256: Some(info.sha256),
+                patch_args: None,
+                patch_tool: None,
+                patches: None,
+            });
+        }
+
+        // Finally, In the event that no spliced source information was included in the
+        // metadata the raw source info is used for registry crates and `crates.io` is
+        // assumed to be the source.
+        if source.is_registry() {
+            return Ok(SourceAnnotation::Http {
+                url: format!(
+                    "https://crates.io/api/v1/crates/{}/{}/download",
+                    lock_pkg.name, lock_pkg.version,
+                ),
+                sha256: lock_pkg
+                    .checksum
+                    .as_ref()
+                    .and_then(|sum| {
+                        if sum.is_sha256() {
+                            sum.as_sha256()
+                        } else {
+                            None
+                        }
+                    })
+                    .map(|sum| sum.encode_hex::<String>()),
+                patch_args: None,
+                patch_tool: None,
+                patches: None,
+            });
+        }
+
+        bail!(
+            "Unable to determine source annotation for '{:?} {:?}",
+            lock_pkg.name,
+            lock_pkg.version
+        )
+    }
+
+    fn find_source_annotation(
+        package: &cargo_lock::Package,
+        metadata: &WorkspaceMetadata,
+    ) -> Option<SourceInfo> {
+        let crate_id = CrateId::new(package.name.to_string(), package.version.to_string());
+        metadata.sources.get(&crate_id).cloned()
+    }
+
+    fn extract_git_strip_prefix(pkg: &Package) -> Result<Option<String>> {
+        // {CARGO_HOME}/git/checkouts/name-hash/short-sha/[strip_prefix...]/Cargo.toml
+        let components = pkg
+            .manifest_path
+            .components()
+            .map(|v| v.to_string())
+            .collect::<Vec<_>>();
+        for (i, _) in components.iter().enumerate() {
+            let possible_components = &components[i..];
+            if possible_components.len() < 5 {
+                continue;
+            }
+            if possible_components[0] != "git"
+                || possible_components[1] != "checkouts"
+                || possible_components[possible_components.len() - 1] != "Cargo.toml"
+            {
+                continue;
+            }
+            if possible_components.len() == 5 {
+                return Ok(None);
+            }
+            return Ok(Some(
+                possible_components[4..(possible_components.len() - 1)].join("/"),
+            ));
+        }
+        bail!("Expected git package to have a manifest path of pattern {{CARGO_HOME}}/git/checkouts/[name]-[hash]/[short-sha]/.../Cargo.toml but {:?} had manifest path {}", pkg.id, pkg.manifest_path);
+    }
+}
+
+/// A pairring of a crate's package identifier to it's annotations.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PairredExtras {
+    /// The crate's package identifier
+    pub package_id: cargo_metadata::PackageId,
+
+    /// The crate's annotations
+    pub crate_extra: CrateAnnotations,
+}
+
+/// A collection of data which has been processed for optimal use in generating Bazel targets.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Annotations {
+    /// Annotated Cargo metadata
+    pub metadata: MetadataAnnotation,
+
+    /// Annotated Cargo lockfile
+    pub lockfile: LockfileAnnotation,
+
+    /// The current workspace's configuration settings
+    pub config: Config,
+
+    /// Pairred crate annotations
+    pub pairred_extras: BTreeMap<CrateId, PairredExtras>,
+}
+
+impl Annotations {
+    pub fn new(
+        cargo_metadata: CargoMetadata,
+        cargo_lockfile: CargoLockfile,
+        config: Config,
+    ) -> Result<Self> {
+        let lockfile_annotation = LockfileAnnotation::new(cargo_lockfile, &cargo_metadata)?;
+
+        // Annotate the cargo metadata
+        let metadata_annotation = MetadataAnnotation::new(cargo_metadata);
+
+        let mut unused_extra_annotations = config.annotations.clone();
+
+        // Ensure each override matches a particular package
+        let pairred_extras = metadata_annotation
+            .packages
+            .iter()
+            .filter_map(|(pkg_id, pkg)| {
+                let extras: Vec<CrateAnnotations> = config
+                    .annotations
+                    .iter()
+                    .filter(|(id, _)| id.matches(pkg))
+                    .map(|(id, extra)| {
+                        // Mark that an annotation has been consumed
+                        unused_extra_annotations.remove(id);
+
+                        // Fitler out the annotation
+                        extra
+                    })
+                    .cloned()
+                    .collect();
+
+                if !extras.is_empty() {
+                    Some((
+                        CrateId::new(pkg.name.clone(), pkg.version.to_string()),
+                        PairredExtras {
+                            package_id: pkg_id.clone(),
+                            crate_extra: extras.into_iter().sum(),
+                        },
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        // Alert on any unused annotations
+        if !unused_extra_annotations.is_empty() {
+            bail!(
+                "Unused annotations were provided. Please remove them: {:?}",
+                unused_extra_annotations.keys()
+            );
+        }
+
+        // Annotate metadata
+        Ok(Annotations {
+            metadata: metadata_annotation,
+            lockfile: lockfile_annotation,
+            config,
+            pairred_extras,
+        })
+    }
+}
+
+fn find_workspace_metadata(cargo_metadata: &CargoMetadata) -> Option<WorkspaceMetadata> {
+    WorkspaceMetadata::try_from(cargo_metadata.workspace_metadata.clone()).ok()
+}
+
+/// Determines whether or not a package is a workspace member. This follows
+/// the Cargo definition of a workspace memeber with one exception where
+/// "extra workspace members" are *not* treated as workspace members
+fn is_workspace_member(id: &PackageId, cargo_metadata: &CargoMetadata) -> bool {
+    if cargo_metadata.workspace_members.contains(id) {
+        if let Some(data) = find_workspace_metadata(cargo_metadata) {
+            let pkg = &cargo_metadata[id];
+            let crate_id = CrateId::new(pkg.name.clone(), pkg.version.to_string());
+
+            !data.sources.contains_key(&crate_id)
+        } else {
+            true
+        }
+    } else {
+        false
+    }
+}
+
+/// Match a [cargo_metadata::Package] to a [cargo_lock::Package].
+fn cargo_meta_pkg_to_locked_pkg<'a>(
+    pkg: &Package,
+    lock_packages: &'a [cargo_lock::Package],
+) -> Option<&'a cargo_lock::Package> {
+    lock_packages
+        .iter()
+        .find(|lock_pkg| lock_pkg.name.as_str() == pkg.name && lock_pkg.version == pkg.version)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::test::*;
+
+    #[test]
+    fn test_cargo_meta_pkg_to_locked_pkg() {
+        let pkg = mock_cargo_metadata_package();
+        let lock_pkg = mock_cargo_lock_package();
+
+        assert!(cargo_meta_pkg_to_locked_pkg(&pkg, &vec![lock_pkg]).is_some())
+    }
+
+    #[test]
+    fn annotate_metadata_with_aliases() {
+        let annotations = MetadataAnnotation::new(test::metadata::alias());
+        let log_crates: BTreeMap<&PackageId, &CrateAnnotation> = annotations
+            .crates
+            .iter()
+            .filter(|(id, _)| {
+                let pkg = &annotations.packages[*id];
+                pkg.name == "log"
+            })
+            .collect();
+
+        assert_eq!(log_crates.len(), 2);
+    }
+
+    #[test]
+    fn annotate_lockfile_with_aliases() {
+        LockfileAnnotation::new(test::lockfile::alias(), &test::metadata::alias()).unwrap();
+    }
+
+    #[test]
+    fn annotate_metadata_with_build_scripts() {
+        MetadataAnnotation::new(test::metadata::build_scripts());
+    }
+
+    #[test]
+    fn annotate_lockfile_with_build_scripts() {
+        LockfileAnnotation::new(
+            test::lockfile::build_scripts(),
+            &test::metadata::build_scripts(),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn annotate_metadata_with_no_deps() {}
+
+    #[test]
+    fn annotate_lockfile_with_no_deps() {
+        LockfileAnnotation::new(test::lockfile::no_deps(), &test::metadata::no_deps()).unwrap();
+    }
+
+    #[test]
+    fn detects_strip_prefix_for_git_repo() {
+        let crates =
+            LockfileAnnotation::new(test::lockfile::git_repos(), &test::metadata::git_repos())
+                .unwrap()
+                .crates;
+        let tracing_core = crates
+            .iter()
+            .find(|(k, _)| k.repr.starts_with("tracing-core "))
+            .map(|(_, v)| v)
+            .unwrap();
+        match tracing_core {
+            SourceAnnotation::Git {
+                strip_prefix: Some(strip_prefix),
+                ..
+            } if strip_prefix == "tracing-core" => {
+                // Matched correctly.
+            }
+            other => {
+                panic!("Wanted SourceAnnotation::Git with strip_prefix == Some(\"tracing-core\"), got: {:?}", other);
+            }
+        }
+    }
+
+    #[test]
+    fn detect_unused_annotation() {
+        // Create a config with some random annotation
+        let mut config = Config::default();
+        config.annotations.insert(
+            CrateId::new("mock-crate".to_owned(), "0.1.0".to_owned()),
+            CrateAnnotations::default(),
+        );
+
+        let result = Annotations::new(test::metadata::no_deps(), test::lockfile::no_deps(), config);
+        assert!(result.is_err());
+
+        let result_str = format!("{:?}", result);
+        assert!(result_str.contains("Unused annotations were provided. Please remove them"));
+        assert!(result_str.contains("mock-crate"));
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/rendering.rs b/third_party/rules_rust/crate_universe/src/rendering.rs
new file mode 100644
index 0000000..a0570ba
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering.rs
@@ -0,0 +1,470 @@
+//! Tools for rendering and writing BUILD and other Starlark files
+
+mod template_engine;
+
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+use anyhow::{bail, Context as AnyhowContext, Result};
+
+use crate::config::RenderConfig;
+use crate::context::Context;
+use crate::rendering::template_engine::TemplateEngine;
+use crate::splicing::default_splicing_package_crate_id;
+use crate::utils::starlark::Label;
+
+pub struct Renderer {
+    config: RenderConfig,
+    engine: TemplateEngine,
+}
+
+impl Renderer {
+    pub fn new(config: RenderConfig) -> Self {
+        let engine = TemplateEngine::new(&config);
+        Self { config, engine }
+    }
+
+    pub fn render(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+        let mut output = BTreeMap::new();
+
+        output.extend(self.render_build_files(context)?);
+        output.extend(self.render_crates_module(context)?);
+
+        if let Some(vendor_mode) = &self.config.vendor_mode {
+            match vendor_mode {
+                crate::config::VendorMode::Local => {
+                    // Nothing to do for local vendor crate
+                }
+                crate::config::VendorMode::Remote => {
+                    output.extend(self.render_vendor_support_files(context)?);
+                }
+            }
+        }
+
+        Ok(output)
+    }
+
+    fn render_crates_module(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+        let module_label = render_module_label(&self.config.crates_module_template, "defs.bzl")
+            .context("Failed to resolve string to module file label")?;
+        let module_build_label =
+            render_module_label(&self.config.crates_module_template, "BUILD.bazel")
+                .context("Failed to resolve string to module file label")?;
+
+        let mut map = BTreeMap::new();
+        map.insert(
+            Renderer::label_to_path(&module_label),
+            self.engine.render_module_bzl(context)?,
+        );
+        map.insert(
+            Renderer::label_to_path(&module_build_label),
+            self.engine.render_module_build_file(context)?,
+        );
+
+        Ok(map)
+    }
+
+    fn render_build_files(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+        let default_splicing_package_id = default_splicing_package_crate_id();
+        self.engine
+            .render_crate_build_files(context)?
+            .into_iter()
+            // Do not render the default splicing package
+            .filter(|(id, _)| *id != &default_splicing_package_id)
+            // Do not render local packages
+            .filter(|(id, _)| !context.workspace_members.contains_key(id))
+            .map(|(id, content)| {
+                let ctx = &context.crates[id];
+                let label = match render_build_file_template(
+                    &self.config.build_file_template,
+                    &ctx.name,
+                    &ctx.version,
+                ) {
+                    Ok(label) => label,
+                    Err(e) => bail!(e),
+                };
+
+                let filename = Renderer::label_to_path(&label);
+
+                Ok((filename, content))
+            })
+            .collect()
+    }
+
+    fn render_vendor_support_files(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+        let module_label = render_module_label(&self.config.crates_module_template, "crates.bzl")
+            .context("Failed to resolve string to module file label")?;
+
+        let mut map = BTreeMap::new();
+        map.insert(
+            Renderer::label_to_path(&module_label),
+            self.engine.render_vendor_module_file(context)?,
+        );
+
+        Ok(map)
+    }
+
+    fn label_to_path(label: &Label) -> PathBuf {
+        match &label.package {
+            Some(package) => PathBuf::from(format!("{}/{}", package, label.target)),
+            None => PathBuf::from(&label.target),
+        }
+    }
+}
+
+/// Write a set of [CrateContext][crate::context::CrateContext] to disk.
+pub fn write_outputs(
+    outputs: BTreeMap<PathBuf, String>,
+    out_dir: &Path,
+    dry_run: bool,
+) -> Result<()> {
+    let outputs: BTreeMap<PathBuf, String> = outputs
+        .into_iter()
+        .map(|(path, content)| (out_dir.join(path), content))
+        .collect();
+
+    if dry_run {
+        for (path, content) in outputs {
+            println!(
+                "==============================================================================="
+            );
+            println!("{}", path.display());
+            println!(
+                "==============================================================================="
+            );
+            println!("{}\n", content);
+        }
+    } else {
+        for (path, content) in outputs {
+            // Ensure the output directory exists
+            fs::create_dir_all(
+                path.parent()
+                    .expect("All file paths should have valid directories"),
+            )?;
+
+            fs::write(&path, content.as_bytes())
+                .context(format!("Failed to write file to disk: {}", path.display()))?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Render the Bazel label of a crate
+pub fn render_crate_bazel_label(
+    template: &str,
+    repository_name: &str,
+    name: &str,
+    version: &str,
+    target: &str,
+) -> String {
+    template
+        .replace("{repository}", repository_name)
+        .replace("{name}", name)
+        .replace("{version}", version)
+        .replace("{target}", target)
+}
+
+/// Render the Bazel label of a crate
+pub fn render_crate_bazel_repository(
+    template: &str,
+    repository_name: &str,
+    name: &str,
+    version: &str,
+) -> String {
+    template
+        .replace("{repository}", repository_name)
+        .replace("{name}", name)
+        .replace("{version}", version)
+}
+
+/// Render the Bazel label of a crate
+pub fn render_crate_build_file(template: &str, name: &str, version: &str) -> String {
+    template
+        .replace("{name}", name)
+        .replace("{version}", version)
+}
+
+/// Render the Bazel label of a vendor module label
+pub fn render_module_label(template: &str, name: &str) -> Result<Label> {
+    Label::from_str(&template.replace("{file}", name))
+}
+
+/// Render the Bazel label of a platform triple
+pub fn render_platform_constraint_label(template: &str, triple: &str) -> String {
+    template.replace("{triple}", triple)
+}
+
+fn render_build_file_template(template: &str, name: &str, version: &str) -> Result<Label> {
+    Label::from_str(
+        &template
+            .replace("{name}", name)
+            .replace("{version}", version),
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::config::{Config, CrateId, VendorMode};
+    use crate::context::crate_context::{CrateContext, Rule};
+    use crate::context::{BuildScriptAttributes, Context, TargetAttributes};
+    use crate::metadata::Annotations;
+    use crate::test;
+
+    fn mock_render_config() -> RenderConfig {
+        serde_json::from_value(serde_json::json!({
+            "repository_name": "test_rendering"
+        }))
+        .unwrap()
+    }
+
+    fn mock_target_attributes() -> TargetAttributes {
+        TargetAttributes {
+            crate_name: "mock_crate".to_owned(),
+            crate_root: Some("src/root.rs".to_owned()),
+            ..TargetAttributes::default()
+        }
+    }
+
+    #[test]
+    fn render_rust_library() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Library(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output
+            .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
+            .unwrap();
+
+        assert!(build_file_content.contains("rust_library("));
+        assert!(build_file_content.contains("name = \"mock_crate\""));
+    }
+
+    #[test]
+    fn render_cargo_build_script() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::BuildScript(TargetAttributes {
+                    crate_name: "build_script_build".to_owned(),
+                    crate_root: Some("build.rs".to_owned()),
+                    ..TargetAttributes::default()
+                })],
+                // Build script attributes are required.
+                build_script_attrs: Some(BuildScriptAttributes::default()),
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output
+            .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
+            .unwrap();
+
+        assert!(build_file_content.contains("cargo_build_script("));
+        assert!(build_file_content.contains("name = \"build_script_build\""));
+
+        // Ensure `cargo_build_script` requirements are met
+        assert!(build_file_content.contains("name = \"mock_crate_build_script\""));
+    }
+
+    #[test]
+    fn render_proc_macro() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::ProcMacro(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output
+            .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
+            .unwrap();
+
+        assert!(build_file_content.contains("rust_proc_macro("));
+        assert!(build_file_content.contains("name = \"mock_crate\""));
+    }
+
+    #[test]
+    fn render_binary() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Binary(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output
+            .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
+            .unwrap();
+
+        assert!(build_file_content.contains("rust_binary("));
+        assert!(build_file_content.contains("name = \"mock_crate__bin\""));
+    }
+
+    #[test]
+    fn render_additive_build_contents() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Binary(mock_target_attributes())],
+                additive_build_file_content: Some(
+                    "# Hello World from additive section!".to_owned(),
+                ),
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output
+            .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
+            .unwrap();
+
+        assert!(build_file_content.contains("# Hello World from additive section!"));
+    }
+
+    #[test]
+    fn render_aliases() {
+        let annotations = Annotations::new(
+            test::metadata::alias(),
+            test::lockfile::alias(),
+            Config::default(),
+        )
+        .unwrap();
+        let context = Context::new(annotations).unwrap();
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let build_file_content = output.get(&PathBuf::from("BUILD.bazel")).unwrap();
+
+        assert!(build_file_content.contains(r#"name = "names-0.12.1-dev__names","#));
+        assert!(build_file_content.contains(r#"name = "names-0.13.0__names","#));
+    }
+
+    #[test]
+    fn render_crate_repositories() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Library(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        let renderer = Renderer::new(mock_render_config());
+        let output = renderer.render(&context).unwrap();
+
+        let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
+
+        assert!(defs_module.contains("def crate_repositories():"));
+    }
+
+    #[test]
+    fn remote_remote_vendor_mode() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Library(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        // Enable remote vendor mode
+        let config = RenderConfig {
+            vendor_mode: Some(VendorMode::Remote),
+            ..mock_render_config()
+        };
+
+        let renderer = Renderer::new(config);
+        let output = renderer.render(&context).unwrap();
+
+        let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
+        assert!(defs_module.contains("def crate_repositories():"));
+
+        let crates_module = output.get(&PathBuf::from("crates.bzl")).unwrap();
+        assert!(crates_module.contains("def crate_repositories():"));
+    }
+
+    #[test]
+    fn remote_local_vendor_mode() {
+        let mut context = Context::default();
+        let crate_id = CrateId::new("mock_crate".to_owned(), "0.1.0".to_owned());
+        context.crates.insert(
+            crate_id.clone(),
+            CrateContext {
+                name: crate_id.name,
+                version: crate_id.version,
+                targets: vec![Rule::Library(mock_target_attributes())],
+                ..CrateContext::default()
+            },
+        );
+
+        // Enable local vendor mode
+        let config = RenderConfig {
+            vendor_mode: Some(VendorMode::Local),
+            ..mock_render_config()
+        };
+
+        let renderer = Renderer::new(config);
+        let output = renderer.render(&context).unwrap();
+
+        // Local vendoring does not produce a `crate_repositories` macro
+        let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
+        assert!(!defs_module.contains("def crate_repositories():"));
+
+        // Local vendoring does not produce a `crates.bzl` file.
+        assert!(output.get(&PathBuf::from("crates.bzl")).is_none());
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/template_engine.rs b/third_party/rules_rust/crate_universe/src/rendering/template_engine.rs
new file mode 100644
index 0000000..792802f
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/template_engine.rs
@@ -0,0 +1,399 @@
+//! A template engine backed by [Tera] for rendering Files.
+
+use std::collections::HashMap;
+
+use anyhow::{Context as AnyhowContext, Result};
+use serde_json::{from_value, to_value, Value};
+use tera::{self, Tera};
+
+use crate::config::{CrateId, RenderConfig};
+use crate::context::Context;
+use crate::rendering::{
+    render_crate_bazel_label, render_crate_bazel_repository, render_crate_build_file,
+    render_module_label, render_platform_constraint_label,
+};
+use crate::utils::sanitize_module_name;
+use crate::utils::sanitize_repository_name;
+use crate::utils::starlark::{SelectStringDict, SelectStringList};
+
+pub struct TemplateEngine {
+    engine: Tera,
+    context: tera::Context,
+}
+
+impl TemplateEngine {
+    pub fn new(render_config: &RenderConfig) -> Self {
+        let mut tera = Tera::default();
+        tera.add_raw_templates(vec![
+            (
+                "partials/crate/aliases.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/aliases.j2"
+                )),
+            ),
+            (
+                "partials/crate/binary.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/binary.j2"
+                )),
+            ),
+            (
+                "partials/crate/build_script.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/build_script.j2"
+                )),
+            ),
+            (
+                "partials/crate/common_attrs.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/common_attrs.j2"
+                )),
+            ),
+            (
+                "partials/crate/deps.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/deps.j2"
+                )),
+            ),
+            (
+                "partials/crate/library.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/library.j2"
+                )),
+            ),
+            (
+                "partials/crate/proc_macro.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/crate/proc_macro.j2"
+                )),
+            ),
+            (
+                "partials/module/aliases_map.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/module/aliases_map.j2"
+                )),
+            ),
+            (
+                "partials/module/deps_map.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/module/deps_map.j2"
+                )),
+            ),
+            (
+                "partials/module/repo_git.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/module/repo_git.j2"
+                )),
+            ),
+            (
+                "partials/module/repo_http.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/module/repo_http.j2"
+                )),
+            ),
+            (
+                "partials/starlark/glob.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/starlark/glob.j2"
+                )),
+            ),
+            (
+                "partials/starlark/selectable_dict.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/starlark/selectable_dict.j2"
+                )),
+            ),
+            (
+                "partials/starlark/selectable_list.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/starlark/selectable_list.j2"
+                )),
+            ),
+            (
+                "partials/header.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/partials/header.j2"
+                )),
+            ),
+            (
+                "crate_build_file.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/crate_build_file.j2"
+                )),
+            ),
+            (
+                "module_build_file.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/module_build_file.j2"
+                )),
+            ),
+            (
+                "module_bzl.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/module_bzl.j2"
+                )),
+            ),
+            (
+                "vendor_module.j2",
+                include_str!(concat!(
+                    env!("CARGO_MANIFEST_DIR"),
+                    "/src/rendering/templates/vendor_module.j2"
+                )),
+            ),
+        ])
+        .unwrap();
+
+        tera.register_function(
+            "crate_build_file",
+            crate_build_file_fn_generator(render_config.build_file_template.clone()),
+        );
+        tera.register_function(
+            "crate_label",
+            crate_label_fn_generator(
+                render_config.crate_label_template.clone(),
+                render_config.repository_name.clone(),
+            ),
+        );
+        tera.register_function(
+            "crate_repository",
+            crate_repository_fn_generator(
+                render_config.crate_repository_template.clone(),
+                render_config.repository_name.clone(),
+            ),
+        );
+        tera.register_function(
+            "platform_label",
+            platform_label_fn_generator(render_config.platforms_template.clone()),
+        );
+        tera.register_function("sanitize_module_name", sanitize_module_name_fn);
+        tera.register_function(
+            "crates_module_label",
+            module_label_fn_generator(render_config.crates_module_template.clone()),
+        );
+
+        let mut context = tera::Context::new();
+        context.insert("default_select_list", &SelectStringList::default());
+        context.insert("default_select_dict", &SelectStringDict::default());
+        context.insert("repository_name", &render_config.repository_name);
+        context.insert("vendor_mode", &render_config.vendor_mode);
+        context.insert("Null", &tera::Value::Null);
+        context.insert(
+            "default_package_name",
+            &match render_config.default_package_name.as_ref() {
+                Some(pkg_name) => format!("\"{}\"", pkg_name),
+                None => "None".to_owned(),
+            },
+        );
+
+        Self {
+            engine: tera,
+            context,
+        }
+    }
+
+    fn new_tera_ctx(&self) -> tera::Context {
+        self.context.clone()
+    }
+
+    pub fn render_crate_build_files<'a>(
+        &self,
+        ctx: &'a Context,
+    ) -> Result<HashMap<&'a CrateId, String>> {
+        // Create the render context with the global planned context to be
+        // reused when rendering crates.
+        let mut context = self.new_tera_ctx();
+        context.insert("context", ctx);
+
+        ctx.crates
+            .iter()
+            .map(|(id, _)| {
+                let aliases = ctx.crate_aliases(id, false, false);
+                let build_aliases = ctx.crate_aliases(id, true, false);
+
+                context.insert("crate_id", &id);
+                context.insert("common_aliases", &aliases);
+                context.insert("build_aliases", &build_aliases);
+
+                let content = self
+                    .engine
+                    .render("crate_build_file.j2", &context)
+                    .context("Failed to render BUILD file")?;
+
+                Ok((id, content))
+            })
+            .collect()
+    }
+
+    pub fn render_module_build_file(&self, data: &Context) -> Result<String> {
+        let mut context = self.new_tera_ctx();
+        context.insert("context", data);
+
+        let workspace_member_deps = data.flat_workspace_member_deps();
+        context.insert("workspace_member_dependencies", &workspace_member_deps);
+
+        let binary_crates_map = data.flat_binary_deps();
+        context.insert("binary_crates_map", &binary_crates_map);
+
+        self.engine
+            .render("module_build_file.j2", &context)
+            .context("Failed to render crates module")
+    }
+
+    pub fn render_module_bzl(&self, data: &Context) -> Result<String> {
+        let mut context = self.new_tera_ctx();
+        context.insert("context", data);
+
+        self.engine
+            .render("module_bzl.j2", &context)
+            .context("Failed to render crates module")
+    }
+
+    pub fn render_vendor_module_file(&self, data: &Context) -> Result<String> {
+        let mut context = self.new_tera_ctx();
+        context.insert("context", data);
+
+        self.engine
+            .render("vendor_module.j2", &context)
+            .context("Failed to render vendor module")
+    }
+}
+
+/// A convienience wrapper for parsing parameters to tera functions
+macro_rules! parse_tera_param {
+    ($param:literal, $param_type:ty, $args:ident) => {
+        match $args.get($param) {
+            Some(val) => match from_value::<$param_type>(val.clone()) {
+                Ok(v) => v,
+                Err(_) => {
+                    return Err(tera::Error::msg(format!(
+                        "The `{}` paramater could not be parsed as a String.",
+                        $param
+                    )))
+                }
+            },
+            None => {
+                return Err(tera::Error::msg(format!(
+                    "No `{}` parameter was passed.",
+                    $param
+                )))
+            }
+        }
+    };
+}
+
+/// Convert a crate name into a module name by applying transforms to invalid characters.
+fn sanitize_module_name_fn(args: &HashMap<String, Value>) -> tera::Result<Value> {
+    let crate_name = parse_tera_param!("crate_name", String, args);
+
+    match to_value(sanitize_module_name(&crate_name)) {
+        Ok(v) => Ok(v),
+        Err(_) => Err(tera::Error::msg("Failed to generate resulting module name")),
+    }
+}
+
+/// Convert a crate name into a module name by applying transforms to invalid characters.
+fn platform_label_fn_generator(template: String) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let triple = parse_tera_param!("triple", String, args);
+            match to_value(render_platform_constraint_label(&template, &triple)) {
+                Ok(v) => Ok(v),
+                Err(_) => Err(tera::Error::msg("Failed to generate resulting module name")),
+            }
+        },
+    )
+}
+
+/// Convert a crate name into a module name by applying transforms to invalid characters.
+fn crate_build_file_fn_generator(template: String) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let name = parse_tera_param!("name", String, args);
+            let version = parse_tera_param!("version", String, args);
+
+            match to_value(render_crate_build_file(&template, &name, &version)) {
+                Ok(v) => Ok(v),
+                Err(_) => Err(tera::Error::msg("Failed to generate crate's BUILD file")),
+            }
+        },
+    )
+}
+
+/// Convert a file name to a Bazel label
+fn module_label_fn_generator(template: String) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let file = parse_tera_param!("file", String, args);
+
+            let label = match render_module_label(&template, &file) {
+                Ok(v) => v,
+                Err(e) => return Err(tera::Error::msg(e)),
+            };
+
+            match to_value(label.to_string()) {
+                Ok(v) => Ok(v),
+                Err(_) => Err(tera::Error::msg("Failed to generate crate's BUILD file")),
+            }
+        },
+    )
+}
+
+/// Convert a crate name into a module name by applying transforms to invalid characters.
+fn crate_label_fn_generator(template: String, repository_name: String) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let name = parse_tera_param!("name", String, args);
+            let version = parse_tera_param!("version", String, args);
+            let target = parse_tera_param!("target", String, args);
+
+            match to_value(sanitize_repository_name(&render_crate_bazel_label(
+                &template,
+                &repository_name,
+                &name,
+                &version,
+                &target,
+            ))) {
+                Ok(v) => Ok(v),
+                Err(_) => Err(tera::Error::msg("Failed to generate crate's label")),
+            }
+        },
+    )
+}
+
+/// Convert a crate name into a module name by applying transforms to invalid characters.
+fn crate_repository_fn_generator(template: String, repository_name: String) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let name = parse_tera_param!("name", String, args);
+            let version = parse_tera_param!("version", String, args);
+
+            match to_value(sanitize_repository_name(&render_crate_bazel_repository(
+                &template,
+                &repository_name,
+                &name,
+                &version,
+            ))) {
+                Ok(v) => Ok(v),
+                Err(_) => Err(tera::Error::msg("Failed to generate crate repository name")),
+            }
+        },
+    )
+}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/crate_build_file.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/crate_build_file.j2
new file mode 100644
index 0000000..ff9d4ad
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/crate_build_file.j2
@@ -0,0 +1,44 @@
+{%- set crate = context.crates | get(key=crate_id) %}
+{%- include "partials/header.j2" %}
+
+load(
+    "@bazel_skylib//lib:selects.bzl", 
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # {{ crate.license }}
+# ])
+
+{% for rule in crate.targets -%}
+{%- for rule_type, target in rule %}
+{%- if rule_type in ["BuildScript"] %}
+{% include "partials/crate/build_script.j2" %}
+{%- elif rule_type in ["ProcMacro"] %}
+{% include "partials/crate/proc_macro.j2" %}
+{%- elif rule_type in ["Library"] %}
+{% include "partials/crate/library.j2" %}
+{%- elif rule_type in ["Binary"] %}
+{% include "partials/crate/binary.j2" %}
+{%- endif %}
+{%- endfor %}
+{%- endfor %}
+{%- if crate.additive_build_file_content %}
+# Additive BUILD file content
+{{ crate.additive_build_file_content }}
+{%- endif %}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/module_build_file.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/module_build_file.j2
new file mode 100644
index 0000000..63124dc
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/module_build_file.j2
@@ -0,0 +1,49 @@
+{%- include "partials/header.j2" %}
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+        {%- set current_vendor_mode = vendor_mode | default(value="") %}{%- if current_vendor_mode == "remote" %}"crates.bzl",{%- endif %}
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+{%- for dep, rename in workspace_member_dependencies %}
+{%- set crate = context.crates | get(key=dep) %}
+{%- if crate | get(key="library_target_name", default=Null) %}
+alias(
+    name = "{{ rename | default(value=crate.name) }}",
+    actual = "{{ crate_label(name = crate.name, version = crate.version, target = crate.library_target_name) }}",
+    tags = ["manual"],
+)
+{%- endif %}
+{%- endfor %}
+
+# Binaries
+{%- for id, rename in binary_crates_map %}
+{%- set crate = context.crates | get(key=id) %}
+{%- for rule in crate.targets %}
+{%- for rule_type, target in rule %}
+{%- if rule_type in ["Binary"] %}
+alias(
+    name = "{{ rename | default(value=crate.name) }}__{{ target.crate_name }}",
+    actual = "{{ crate_label(name = crate.name, version = crate.version, target = target.crate_name ~ '__bin') }}",
+    tags = ["manual"],
+)
+{%- endif %}
+{%- endfor %}
+{%- endfor %}
+{%- endfor %}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/module_bzl.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/module_bzl.j2
new file mode 100644
index 0000000..4ea1624
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/module_bzl.j2
@@ -0,0 +1,338 @@
+{#
+To keep line numbers consistent with the rendered version, empty space is
+intentionally plced here which should match the line length of `partials/header.j2`.
+
+Expected length = 6 lines
+#}{%- include "partials/header.j2" %}
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = {{ default_package_name }}):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False, 
+        normal_dev = False, 
+        proc_macro = False, 
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = {{ default_package_name }}):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = {{ default_package_name }}):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {% set deps_type = "normal" %}{% include "partials/module/deps_map.j2" %}
+
+_NORMAL_ALIASES = {% set deps_type = "normal" %}{% include "partials/module/aliases_map.j2" %}
+
+_NORMAL_DEV_DEPENDENCIES = {% set deps_type = "normal-dev" %}{% include "partials/module/deps_map.j2" %}
+
+_NORMAL_DEV_ALIASES = {% set deps_type = "normal-dev" %}{% include "partials/module/aliases_map.j2" %}
+
+_PROC_MACRO_DEPENDENCIES = {% set deps_type = "proc-macro" %}{% include "partials/module/deps_map.j2" %}
+
+_PROC_MACRO_ALIASES = {% set deps_type = "proc-macro-dev" %}{% include "partials/module/aliases_map.j2" %}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {% set deps_type = "proc-macro-dev" %}{% include "partials/module/deps_map.j2" %}
+
+_PROC_MACRO_DEV_ALIASES = {% set deps_type = "normal-dev" %}{% include "partials/module/aliases_map.j2" %}
+
+_BUILD_DEPENDENCIES = {% set deps_type = "build" %}{% include "partials/module/deps_map.j2" %}
+
+_BUILD_ALIASES = {% set deps_type = "build" %}{% include "partials/module/aliases_map.j2" %}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {% set deps_type = "build-proc-macro" %}{% include "partials/module/deps_map.j2" %}
+
+_BUILD_PROC_MACRO_ALIASES = {% set deps_type = "build-proc-macro" %}{% include "partials/module/aliases_map.j2" %}
+
+_CONDITIONS = {
+{%- for condition, triples in context.conditions %}
+    "{{ condition | addslashes }}": {{ triples | sort | json_encode | safe }},
+{%- endfor %}
+}
+{% set current_vendor_mode = vendor_mode | default(value="remote") %}{% if current_vendor_mode == "remote" %}
+###############################################################################
+
+def crate_repositories():
+    """A macro for defining repositories for all generated crates"""
+{%- if context.crates | length %}
+{%- for id, crate in context.crates %}
+{%- if not crate.repository %}{% continue %}{% endif %}
+{%- for repository_type, attrs in crate.repository %}
+{%- if repository_type in ["Http"] %}
+{% include "partials/module/repo_http.j2" %}
+{%- elif repository_type in ["Git"] %}
+{% include "partials/module/repo_git.j2" %}
+{%- else %}
+    {{ throw(message = "Unsupported checksum type: " ~ repository_type) }}
+{%- endif %}
+{%- endfor %}
+{%- endfor %}
+{%- else %}
+    pass
+{%- endif %}
+{%- endif %}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/aliases.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/aliases.j2
new file mode 100644
index 0000000..5c4b67e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/aliases.j2
@@ -0,0 +1,32 @@
+selects.with_or({
+    {%- for cfg, values in selectable.selects %}
+    {%- if cfg in context.conditions and context.conditions[cfg] | length %}
+        # {{ cfg }}
+        (
+            {%- for triple in context.conditions[cfg] %}
+            "{{ platform_label(triple = triple) }}",
+            {%- endfor %}
+        ): {
+            {%- for dep in values %}
+            {%- set dep_crate = context.crates | get(key=dep.id) %}
+            "{{ crate_label(name = dep_crate.name, version = dep_crate.version, target = dep.target) }}": "{{ dep.alias }}",
+            {%- endfor %}
+            {%- for dep in selectable.common %}
+            {%- set dep_crate = context.crates | get(key=dep.id) %}
+            "{{ crate_label(name = dep_crate.name, version = dep_crate.version, target = dep.target) }}": "{{ dep.alias }}",
+            {%- endfor %}
+        },
+    {%- else %}
+        # {
+        # No supported platform triples for cfg: '{{ cfg }}'
+        # Skipped dependencies: {{ values | json_encode | safe }}
+        # }
+    {%- endif %}
+    {%- endfor %}
+        "//conditions:default": {
+            {%- for dep in selectable.common %}
+            {%- set dep_crate = context.crates | get(key=dep.id) %}
+            "{{ crate_label(name = dep_crate.name, version = dep_crate.version, target = dep.target) }}": "{{ dep.alias }}",
+            {%- endfor %}
+        },
+    })
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/binary.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/binary.j2
new file mode 100644
index 0000000..2cdc5d9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/binary.j2
@@ -0,0 +1,18 @@
+rust_binary(
+    name = "{{ target.crate_name }}__bin",
+    deps = [
+        {%- if crate.library_target_name %}
+        ":{{ crate.library_target_name }}",
+        {%- endif %}
+        {%- for dep in crate.common_attrs | get(key="extra_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    proc_macro_deps = [
+        {%- for dep in crate.common_attrs | get(key="extra_proc_macro_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="proc_macro_deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    aliases = {% set selectable = common_aliases %}{% include "partials/crate/aliases.j2" -%},
+{% include "partials/crate/common_attrs.j2" %}
+)
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/build_script.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/build_script.j2
new file mode 100644
index 0000000..45b97f7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/build_script.j2
@@ -0,0 +1,70 @@
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "{{ crate.name }}_build_script",
+    aliases = {% set selectable = build_aliases %}{% include "partials/crate/aliases.j2" -%},
+    build_script_env = {% set selectable = crate.build_script_attrs | get(key="build_script_env", default=Null) %}{% include "partials/starlark/selectable_dict.j2" -%},
+    compile_data = {% if crate.build_script_attrs | get(key="compile_data_glob") %}glob({{ crate.build_script_attrs.compile_data_glob | json_encode | safe }}) + {% endif %}{% set selectable = crate.build_script_attrs | get(key="compile_data", default=Null) %}{% include "partials/starlark/selectable_list.j2" %},
+    crate_name = "{{ sanitize_module_name(crate_name=target.crate_name) }}",
+    crate_root = "{{ target.crate_root }}",
+    crate_features = [
+        {%- if crate.common_attrs | get(key="crate_features", default=Null) %}
+        {%- for feature in crate.common_attrs.crate_features %}
+        "{{ feature }}",
+        {%- endfor %}
+        {%- endif %}
+    ],
+    data = {% if crate.build_script_attrs | get(key="data_glob") %}glob({{ crate.build_script_attrs.data_glob | json_encode | safe }}) + {% endif %}{% set selectable = crate.build_script_attrs | get(key="data", default=Null) %}{% include "partials/starlark/selectable_list.j2" %},
+    deps = [
+        {%- for dep in crate.build_script_attrs | get(key="extra_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.build_script_attrs | get(key="deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    edition = "{{ crate.common_attrs.edition }}",
+    {%- if crate.common_attrs.linker_script %}
+    linker_script = "{{ crate.common_attrs.linker_script }}",
+    {%- endif %}
+    {%- if crate.build_script_attrs | get(key="links", default=Null) %}
+    links = "{{ crate.build_script_attrs.links }}",
+    {%- endif %}
+    proc_macro_deps = [
+        {%- for dep in crate.build_script_attrs | get(key="extra_proc_macro_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.build_script_attrs | get(key="proc_macro_deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    rustc_env = {% set selectable = crate.build_script_attrs | get(key="rustc_env", default=Null) %}{% include "partials/starlark/selectable_dict.j2" -%},
+    rustc_env_files = {% set selectable = crate.build_script_attrs | get(key="rustc_env_files", default=Null) %}{% include "partials/starlark/selectable_list.j2" %},
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences 
+        # warnings. For more details see: 
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + {% set selectable = crate.build_script_attrs | get(key="rustc_flags", default=Null) %}{% include "partials/starlark/selectable_list.j2" %},
+    srcs = {% set glob = target.srcs %}{% include "partials/starlark/glob.j2" -%},
+    tools = {% set selectable = crate.build_script_attrs | get(key="tools", default=Null) %}{% include "partials/starlark/selectable_list.j2" %},
+    version = "{{ crate.common_attrs.version }}",
+    tags = [
+        {%- if crate.common_attrs | get(key="tags", default=Null) %}
+        {%- for tag in crate.common_attrs.tags %}
+        "{{ tag }}",
+        {%- endfor %}
+        {%- endif %}
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    visibility = ["//visibility:private"],
+)
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "{{ target.crate_name }}",
+    actual = "{{ crate.name }}_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/common_attrs.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/common_attrs.j2
new file mode 100644
index 0000000..a381f44
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/common_attrs.j2
@@ -0,0 +1,34 @@
+    compile_data = {% if crate.common_attrs | get(key="compile_data_glob") %}glob({{ crate.common_attrs.compile_data_glob | json_encode | safe }}) + {% endif %}{% set selectable = crate.common_attrs | get(key="compile_data", default=default_select_list) %}{% include "partials/starlark/selectable_list.j2" -%},
+    crate_root = "{{ target.crate_root }}",
+    crate_features = [
+        {%- for feature in crate.common_attrs | get(key="crate_features", default=[]) %}
+        "{{ feature }}",
+        {%- endfor %}
+    ],
+    data = {% if crate.common_attrs | get(key="data_glob") %}glob({{ crate.common_attrs.data_glob | json_encode | safe }}) + {% endif %}{% set selectable = crate.common_attrs | get(key="data", default=default_select_list) %}{% include "partials/starlark/selectable_list.j2" -%},
+    edition = "{{ crate.common_attrs.edition }}",
+    {%- if crate.common_attrs | get(key="linker_script", default=Null) %}
+    linker_script = "{{ crate.common_attrs.linker_script }}",
+    {%- endif %}
+    rustc_env = {% set selectable = crate.common_attrs | get(key="rustc_env", default=Null) %}{% include "partials/starlark/selectable_dict.j2" -%},
+    rustc_env_files = {% set selectable = crate.common_attrs | get(key="rustc_env_files", default=Null) %}{% include "partials/starlark/selectable_list.j2" -%},
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences 
+        # warnings. For more details see: 
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + {% set selectable = crate.common_attrs | get(key="rustc_flags", default=Null) %}{% include "partials/starlark/selectable_list.j2" -%},
+    srcs = {% set glob = target.srcs %}{% include "partials/starlark/glob.j2" -%},
+    version = "{{ crate.common_attrs.version }}",
+    tags = [
+        {%- if crate.common_attrs | get(key="tags", default=Null) %}
+        {%- for tag in crate.common_attrs.tags %}
+        "{{ tag }}",
+        {%- endfor %}
+        {%- endif %}
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/deps.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/deps.j2
new file mode 100644
index 0000000..0e0bf71
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/deps.j2
@@ -0,0 +1,36 @@
+select_with_or({
+    {%- set selectable = deps | default(value=default_select_list) %}
+    {%- for cfg, values in selectable.selects %}
+        # {{ cfg }}
+    {%- if cfg in context.conditions and context.conditions[cfg] | length %}
+        (
+            {%- for triple in context.conditions[cfg] %}
+            "{{ platform_label(triple = triple) }}",
+            {%- endfor %}
+        ): [
+            # Target Deps
+            {%- for dep in values %}
+            {%- set dep_crate = context.crates | get(key=dep.id) %}
+            "{{ crate_label(name = dep_crate.name, version = dep_crate.version, target = dep.target) }}",
+            {%- endfor %}
+
+            # Common Deps
+            {%- for common_dep in selectable.common %}
+            {%- set common_dep_crate = context.crates | get(key=common_dep.id) %}
+            "{{ crate_label(name = common_dep_crate.name, version = common_dep_crate.version, target = common_dep.target) }}",
+            {%- endfor %}
+        ],
+    {%- else %}
+            #
+            # No supported platform triples for cfg: '{{ cfg }}'
+            # Skipped dependencies: {{ values | json_encode | safe }}
+            #
+    {%- endif %}
+    {%- endfor %}
+        "//conditions:default": [
+            {%- for common_dep in selectable.common %}
+            {%- set common_dep_crate = context.crates | get(key=common_dep.id) %}
+            "{{ crate_label(name = common_dep_crate.name, version = common_dep_crate.version, target = common_dep.target) }}",
+            {%- endfor %}
+        ],
+    })
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/library.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/library.j2
new file mode 100644
index 0000000..f678bd9
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/library.j2
@@ -0,0 +1,15 @@
+rust_library(
+    name = "{{ target.crate_name }}",
+    deps = [
+        {%- for dep in crate.common_attrs | get(key="extra_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    proc_macro_deps = [
+        {%- for dep in crate.common_attrs | get(key="extra_proc_macro_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="proc_macro_deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    aliases = {% set selectable = common_aliases %}{% include "partials/crate/aliases.j2" -%},
+{% include "partials/crate/common_attrs.j2" %}
+)
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/proc_macro.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/proc_macro.j2
new file mode 100644
index 0000000..c0b9d1d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/crate/proc_macro.j2
@@ -0,0 +1,15 @@
+rust_proc_macro(
+    name = "{{ target.crate_name }}",
+    deps = [
+        {%- for dep in crate.common_attrs | get(key="extra_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    proc_macro_deps = [
+        {%- for dep in crate.common_attrs | get(key="extra_proc_macro_deps", default=[]) %}
+        "{{ dep }}",
+        {%- endfor %}
+    ] + {% set deps = crate.common_attrs | get(key="proc_macro_deps", default=Null) %}{% include "partials/crate/deps.j2" %},
+    aliases = {% set selectable = common_aliases %}{% include "partials/crate/aliases.j2" -%},
+{% include "partials/crate/common_attrs.j2" %}
+)
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/header.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/header.j2
new file mode 100644
index 0000000..6f88e85
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/header.j2
@@ -0,0 +1,6 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/aliases_map.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/aliases_map.j2
new file mode 100644
index 0000000..73d736e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/aliases_map.j2
@@ -0,0 +1,53 @@
+{
+    {%- for id, path in context.workspace_members %}
+    {%- set workspace_member = context.crates | get(key=id) %}
+    "{{ path }}": {
+    {%- if deps_type in ["normal"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="deps", default=default_select_list) %}
+    {%- elif deps_type in ["normal-dev"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="deps_dev", default=default_select_list) %}
+    {%- elif deps_type in ["proc-macro"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="proc_macro_deps", default=default_select_list) %}
+    {%- elif deps_type in ["proc-macro-dev"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="proc_macro_deps_dev", default=default_select_list) %}
+    {%- elif deps_type in ["build"] %}
+        {%- if workspace_member | get(key="build_script_attrs", default=Null) %}
+        {%- set_global deps_set = workspace_member.build_script_attrs | get(key="deps", default=default_select_list) %}
+        {%- else %}
+        {%- set_global deps_set = default_select_list %}
+        {%- endif %}
+    {%- elif deps_type in ["build-proc-macro"] %}
+        {%- if workspace_member | get(key="build_script_attrs", default=Null) %}
+        {%- set_global deps_set = workspace_member.build_script_attrs | get(key="proc_macro_deps", default=default_select_list) %}
+        {%- else %}
+        {%- set_global deps_set = default_select_list %}
+        {%- endif %}
+    {%- else %}
+    {%- endif %}
+        {%- if deps_set.common | length %}
+        _COMMON_CONDITION: {
+            {%- for dep in deps_set.common %}
+            {%- if dep.id in context.workspace_members %}{% continue %}}{% endif %}{# Workspace member repositories are not defined, skip adding their labels here #}
+            {%- set crate = context.crates | get(key=dep.id) %}
+            {%- if dep | get(key="alias", default=Null) %}
+            "{{ crate_label(name = crate.name, version = crate.version, target = crate.name) }}": "{{ dep.alias }}",
+            {%- endif %}
+            {%- endfor %}
+        },
+        {%- endif %}
+        {%- if deps_set.selects | length %}
+        {%- for condition, deps in deps_set.selects %}
+        "{{ condition | addslashes }}": {
+            {%- for dep in deps %}
+            {%- if dep.id in context.workspace_members %}{% continue %}}{% endif %}{# Workspace member repositories are not defined, skip adding their labels here #}
+            {%- if dep | get(key="alias", default=Null) %}
+            {%- set crate = context.crates | get(key=dep.id) %}
+            "{{ crate_label(name = crate.name, version = crate.version, target = crate.name) }}": "{{ dep.alias }}",
+            {%- endif %}
+            {%- endfor %}
+        },
+        {%- endfor %}
+        {%- endif %}
+    },
+    {%- endfor %}
+}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/deps_map.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/deps_map.j2
new file mode 100644
index 0000000..c9f169d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/deps_map.j2
@@ -0,0 +1,50 @@
+{
+    {%- for id, path in context.workspace_members %}
+    {%- set workspace_member = context.crates | get(key=id) %}
+    "{{ path }}": {
+    {%- if deps_type in ["normal"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="deps", default=default_select_list) %}
+    {%- elif deps_type in ["normal-dev"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="deps_dev", default=default_select_list) %}
+    {%- elif deps_type in ["proc-macro"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="proc_macro_deps", default=default_select_list) %}
+    {%- elif deps_type in ["proc-macro-dev"] %}
+    {%- set_global deps_set = workspace_member.common_attrs | get(key="proc_macro_deps_dev", default=default_select_list) %}
+    {%- elif deps_type in ["build"] %}
+        {%- if workspace_member | get(key="build_script_attrs", default=Null) %}
+        {%- set_global deps_set = workspace_member.build_script_attrs | get(key="deps", default=default_select_list) %}
+        {%- else %}
+        {%- set_global deps_set = default_select_list %}
+        {%- endif %}
+    {%- elif deps_type in ["build-proc-macro"] %}
+        {%- if workspace_member | get(key="build_script_attrs", default=Null) %}
+        {%- set_global deps_set = workspace_member.build_script_attrs | get(key="proc_macro_deps", default=default_select_list) %}
+        {%- else %}
+        {%- set_global deps_set = default_select_list %}
+        {%- endif %}
+    {%- else %}
+    {{ throw(message= "Unexpected dependency type '" ~ deps_type ~ "' for '" ~ id ~ "'") }}
+    {%- endif %}
+        {%- if deps_set.common | length %}
+        _COMMON_CONDITION: {
+            {%- for dep in deps_set.common %}
+            {%- if dep.id in context.workspace_members %}{% continue %}}{% endif %}{# Workspace member repositories are not defined, skip adding their labels here #}
+            {%- set crate = context.crates | get(key=dep.id) %}
+            "{{ dep | get(key="alias", default=crate.name) }}": "{{ crate_label(name = crate.name, version = crate.version, target = dep.target) }}",
+            {%- endfor %}
+        },
+        {%- endif %}
+        {%- if deps_set.selects | length %}
+        {%- for condition, deps in deps_set.selects %}
+        "{{ condition | addslashes }}": {
+            {%- for dep in deps %}
+            {%- if dep.id in context.workspace_members %}{% continue %}}{% endif %}{# Workspace member repositories are not defined, skip adding their labels here #}
+            {%- set crate = context.crates | get(key=dep.id) %}
+            "{{ dep | get(key="alias", default=crate.name) }}": "{{ crate_label(name = crate.name, version = crate.version, target = dep.target) }}",
+            {%- endfor %}
+        },
+        {%- endfor %}
+        {%- endif %}
+    },
+    {%- endfor %}
+}
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_git.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_git.j2
new file mode 100644
index 0000000..3bc2392
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_git.j2
@@ -0,0 +1,41 @@
+    maybe(
+        new_git_repository,
+        name = "{{ crate_repository(name = crate.name, version = crate.version) }}",
+    {%- for type, commitish in attrs.commitish %}
+    {%- if type in ["Rev"] %}
+        commit = "{{ commitish }}",
+    {%- elif type in ["Tag"] %}
+        tag = "{{ commitish }}",
+    {%- elif type in ["Branch"] %}
+        branch = "{{ commitish }}",
+    {%- else %}
+        {{ throw(message= "Unexpected git commitish '" ~ type ~ "' for '" ~ crate.name ~ "'") }}
+    {%- endif %}
+    {%- endfor %}
+        init_submodules = True,
+    {%- if attrs | get(key="patch_args", default=Null) %}
+        patch_args = [
+    {%- for arg in attrs.patch_args %}
+            "{{ arg }}",
+    {%- endfor %}
+        ],
+    {%- endif %}
+    {%- if attrs | get(key="patch_tool", default=Null) %}
+        patch_tool = "{{ attrs.patch_tool }}",
+    {%- endif %}
+    {%- if attrs | get(key="patches", default=Null) %}
+        patches = [
+    {%- for patch in attrs.patches %}
+            "{{ patch }}",
+    {%- endfor %}
+        ],
+    {%- endif %}
+    {%- if attrs | get(key="shallow_since", default=Null) %}
+        shallow_since = "{{ attrs.shallow_since }}",
+    {%- endif %}
+        remote = "{{ attrs.remote }}",
+        build_file = Label("{{ crate_build_file(name = crate.name, version = crate.version)}}"),
+    {%- if attrs.strip_prefix %}
+        strip_prefix = "{{ attrs.strip_prefix }}",
+    {%- endif %}
+    )
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_http.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_http.j2
new file mode 100644
index 0000000..8e3f7dc
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/module/repo_http.j2
@@ -0,0 +1,28 @@
+    maybe(
+        http_archive,
+        name = "{{ crate_repository(name = crate.name, version = crate.version) }}",
+    {%- if attrs | get(key="patch_args", default=Null) %}
+        patch_args = [
+    {%- for arg in attrs.patch_args %}
+            "{{ arg }}",
+    {%- endfor %}
+        ],
+    {%- endif %}
+    {%- if attrs | get(key="patch_tool", default=Null) %}
+        patch_tool = "{{ attrs.patch_tool }}",
+    {%- endif %}
+    {%- if attrs | get(key="patches", default=Null) %}
+        patches = [
+    {%- for patch in attrs.patches %}
+            "{{ patch }}",
+    {%- endfor %}
+        ],
+    {%- endif %}
+    {%- if attrs | get(key="sha256", default=Null) %}
+        sha256 = "{{ attrs.sha256 }}",
+    {%- endif %}
+        type = "tar.gz",
+        urls = ["{{ attrs.url }}"],
+        strip_prefix = "{{ crate.name }}-{{ crate.version }}",
+        build_file = Label("{{ crate_build_file(name = crate.name, version = crate.version)}}"),
+    )
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/glob.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/glob.j2
new file mode 100644
index 0000000..67f70af
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/glob.j2
@@ -0,0 +1,12 @@
+glob(
+        include = [
+            {%- for pattern in glob.include %}
+            "{{ pattern }}",
+            {%- endfor %}
+        ],
+        exclude = [
+            {%- for pattern in glob.exclude %}
+            "{{ pattern }}",
+            {%- endfor %}
+        ],
+    )
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_dict.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_dict.j2
new file mode 100644
index 0000000..8012cc7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_dict.j2
@@ -0,0 +1,36 @@
+{%- set selectable = selectable | default(value=default_select_dict) %}
+{%- if selectable.selects | length -%}
+    selects.with_or({
+    {%- for cfg, map in selectable.selects %}
+    {%- if cfg in context.conditions and context.conditions[cfg] | length %}
+        # {{ cfg }}
+        (
+            {%- for triple in context.conditions[cfg] %}
+            "{{ platform_label(triple = triple) }}",
+            {%- endfor %}
+        ): {
+            {%- if selectable.common | length %}
+            {%- for key, val in selectable.common %}
+            "{{ key }}": "{{ val }}",
+            {%- endfor %}
+            {%- endif %}
+            {%- for key, val in map %}
+            "{{ key }}": "{{ val }}",
+            {%- endfor %}
+        },
+    {%- else %}
+        # No supported platform triples for cfg: '{{ cfg }}'
+        # Skipped dependencies: {{ map | json_encode| safe }}
+    {%- endif %}
+    {%- endfor %}
+        "//conditions:default": {},
+    })
+{%- else -%}
+    {
+        {%- if selectable.common | length %}
+        {%- for key, val in selectable.common %}
+        "{{ key }}": "{{ val }}",
+        {%- endfor %}
+        {%- endif %}
+    }
+{%- endif %}
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_list.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_list.j2
new file mode 100644
index 0000000..2641713
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/partials/starlark/selectable_list.j2
@@ -0,0 +1,31 @@
+select_with_or({
+    {%- set selectable = selectable | default(value=default_select_list) %}
+    {%- for cfg, values in selectable.selects %}
+        # {{ cfg }}
+    {%- if cfg in context.conditions and context.conditions[cfg] | length %}
+        (
+            {%- for triple in context.conditions[cfg] %}
+            "{{ platform_label(triple = triple) }}",
+            {%- endfor %}
+        ): [
+            # Target Deps
+            {%- for val in values %}
+            "{{ val }}",
+            {%- endfor %}
+
+            # Common Deps
+            {%- for val in selectable.common %}
+            "{{ val }}",
+            {%- endfor %}
+        ],
+    {%- else %}
+            # No supported platform triples for cfg: '{{ cfg }}'
+            # Skipped dependencies: {{ values | json_encode | safe }}
+    {%- endif %}
+    {%- endfor %}
+        "//conditions:default": [
+            {%- for val in selectable.common %}
+            "{{ val }}",
+            {%- endfor %}
+        ],
+    })
\ No newline at end of file
diff --git a/third_party/rules_rust/crate_universe/src/rendering/templates/vendor_module.j2 b/third_party/rules_rust/crate_universe/src/rendering/templates/vendor_module.j2
new file mode 100644
index 0000000..74b031e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/rendering/templates/vendor_module.j2
@@ -0,0 +1,25 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""Rules for defining repositories for remote `crates_vendor` repositories"""
+
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:crates_vendor.bzl", "crates_vendor_remote_repository")
+
+# buildifier: disable=bzl-visibility
+load("{{ crates_module_label(file="defs.bzl") }}", _crate_repositories = "crate_repositories")
+
+def crate_repositories():
+    maybe(
+        crates_vendor_remote_repository,
+        name = "{{ repository_name }}",
+        build_file = Label("{{ crates_module_label(file="BUILD.bazel") }}"),
+        defs_module = Label("{{ crates_module_label(file="defs.bzl") }}"),
+    )
+
+    _crate_repositories()
diff --git a/third_party/rules_rust/crate_universe/src/splicing.rs b/third_party/rules_rust/crate_universe/src/splicing.rs
new file mode 100644
index 0000000..0de1daa
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/splicing.rs
@@ -0,0 +1,495 @@
+//! This module is responsible for finding a Cargo workspace
+
+pub(crate) mod cargo_config;
+mod splicer;
+
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::convert::TryFrom;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+use anyhow::{bail, Context, Result};
+use cargo_toml::Manifest;
+use hex::ToHex;
+use serde::{Deserialize, Serialize};
+
+use crate::config::CrateId;
+use crate::metadata::LockGenerator;
+use crate::utils::starlark::Label;
+
+use self::cargo_config::CargoConfig;
+pub use self::splicer::*;
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct ExtraManifestInfo {
+    // The path to a Cargo Manifest
+    pub manifest: PathBuf,
+
+    // The URL where the manifest's package can be downloaded
+    pub url: String,
+
+    // The Sha256 checksum of the downloaded package located at `url`.
+    pub sha256: String,
+}
+
+type DirectPackageManifest = BTreeMap<String, cargo_toml::DependencyDetail>;
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+#[serde(deny_unknown_fields)]
+pub struct SplicingManifest {
+    /// A set of all packages directly written to the rule
+    pub direct_packages: DirectPackageManifest,
+
+    /// A mapping of manifest paths to the labels representing them
+    pub manifests: BTreeMap<PathBuf, Label>,
+
+    /// The path of a Cargo config file
+    pub cargo_config: Option<PathBuf>,
+
+    /// The Cargo resolver version to use for splicing
+    pub resolver_version: cargo_toml::Resolver,
+}
+
+impl FromStr for SplicingManifest {
+    type Err = serde_json::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_json::from_str(s)
+    }
+}
+
+impl SplicingManifest {
+    pub fn try_from_path<T: AsRef<Path>>(path: T) -> Result<Self> {
+        let content = fs::read_to_string(path.as_ref())?;
+        Self::from_str(&content).context("Failed to load SplicingManifest")
+    }
+
+    pub fn absoulutize(self, relative_to: &Path) -> Self {
+        let Self {
+            manifests,
+            cargo_config,
+            ..
+        } = self;
+
+        // Ensure manifests all have absolute paths
+        let manifests = manifests
+            .into_iter()
+            .map(|(path, label)| {
+                if !path.is_absolute() {
+                    let path = relative_to.join(path);
+                    (path, label)
+                } else {
+                    (path, label)
+                }
+            })
+            .collect();
+
+        // Ensure the cargo config is located at an absolute path
+        let cargo_config = cargo_config.map(|path| {
+            if !path.is_absolute() {
+                relative_to.join(path)
+            } else {
+                path
+            }
+        });
+
+        Self {
+            manifests,
+            cargo_config,
+            ..self
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Default)]
+pub struct SplicingMetadata {
+    /// A set of all packages directly written to the rule
+    pub direct_packages: DirectPackageManifest,
+
+    /// A mapping of manifest paths to the labels representing them
+    pub manifests: BTreeMap<Label, cargo_toml::Manifest>,
+
+    /// The path of a Cargo config file
+    pub cargo_config: Option<CargoConfig>,
+}
+
+impl TryFrom<SplicingManifest> for SplicingMetadata {
+    type Error = anyhow::Error;
+
+    fn try_from(value: SplicingManifest) -> Result<Self, Self::Error> {
+        let direct_packages = value.direct_packages;
+
+        let manifests = value
+            .manifests
+            .into_iter()
+            .map(|(path, label)| {
+                let manifest = cargo_toml::Manifest::from_path(&path)
+                    .with_context(|| format!("Failed to load manifest '{}'", path.display()))?;
+
+                Ok((label, manifest))
+            })
+            .collect::<Result<BTreeMap<Label, Manifest>>>()?;
+
+        let cargo_config = match value.cargo_config {
+            Some(path) => Some(
+                CargoConfig::try_from_path(&path)
+                    .with_context(|| format!("Failed to load cargo config '{}'", path.display()))?,
+            ),
+            None => None,
+        };
+
+        Ok(Self {
+            direct_packages,
+            manifests,
+            cargo_config,
+        })
+    }
+}
+
+/// A collection of information required for reproducible "extra worksspace members".
+#[derive(Debug, Default, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ExtraManifestsManifest {
+    pub manifests: Vec<ExtraManifestInfo>,
+}
+
+impl FromStr for ExtraManifestsManifest {
+    type Err = serde_json::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_json::from_str(s)
+    }
+}
+
+impl ExtraManifestsManifest {
+    pub fn try_from_path<T: AsRef<Path>>(path: T) -> Result<Self> {
+        let content = fs::read_to_string(path.as_ref())?;
+        Self::from_str(&content).context("Failed to load ExtraManifestsManifest")
+    }
+
+    pub fn absoulutize(self) -> Self {
+        self
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub struct SourceInfo {
+    /// A url where to a `.crate` file.
+    pub url: String,
+
+    /// The `.crate` file's sha256 checksum.
+    pub sha256: String,
+}
+
+/// Information about the Cargo workspace relative to the Bazel workspace
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct WorkspaceMetadata {
+    /// A mapping of crates to information about where their source can be downloaded
+    #[serde(serialize_with = "toml::ser::tables_last")]
+    pub sources: BTreeMap<CrateId, SourceInfo>,
+
+    /// The path from the root of a Bazel workspace to the root of the Cargo workspace
+    pub workspace_prefix: Option<String>,
+
+    /// Paths from the root of a Bazel workspace to a Cargo package
+    #[serde(serialize_with = "toml::ser::tables_last")]
+    pub package_prefixes: BTreeMap<String, String>,
+}
+
+impl TryFrom<toml::Value> for WorkspaceMetadata {
+    type Error = anyhow::Error;
+
+    fn try_from(value: toml::Value) -> Result<Self, Self::Error> {
+        match value.get("cargo-bazel") {
+            Some(v) => v
+                .to_owned()
+                .try_into()
+                .context("Failed to deserialize toml value"),
+            None => bail!("cargo-bazel workspace metadata not found"),
+        }
+    }
+}
+
+impl TryFrom<serde_json::Value> for WorkspaceMetadata {
+    type Error = anyhow::Error;
+
+    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
+        match value.get("cargo-bazel") {
+            Some(value) => {
+                serde_json::from_value(value.to_owned()).context("Faield to deserialize json value")
+            }
+            None => bail!("cargo-bazel workspace metadata not found"),
+        }
+    }
+}
+
+impl WorkspaceMetadata {
+    fn new(
+        splicing_manifest: &SplicingManifest,
+        extra_manifests_manifest: &ExtraManifestsManifest,
+        injected_manifests: HashMap<&PathBuf, String>,
+    ) -> Result<Self> {
+        let mut sources = BTreeMap::new();
+
+        for config in extra_manifests_manifest.manifests.iter() {
+            let package = match read_manifest(&config.manifest) {
+                Ok(manifest) => match manifest.package {
+                    Some(pkg) => pkg,
+                    None => continue,
+                },
+                Err(e) => return Err(e),
+            };
+
+            let id = CrateId::new(package.name, package.version);
+            let info = SourceInfo {
+                url: config.url.clone(),
+                sha256: config.sha256.clone(),
+            };
+
+            sources.insert(id, info);
+        }
+
+        let mut package_prefixes: BTreeMap<String, String> = injected_manifests
+            .iter()
+            .filter_map(|(original_manifest, cargo_pkg_name)| {
+                let label = match splicing_manifest.manifests.get(*original_manifest) {
+                    Some(v) => v,
+                    None => return None,
+                };
+
+                let package = match &label.package {
+                    Some(pkg) => PathBuf::from(pkg),
+                    None => return None,
+                };
+
+                let prefix = package.to_string_lossy().to_string();
+
+                Some((cargo_pkg_name.clone(), prefix))
+            })
+            .collect();
+
+        // It is invald for toml maps to use empty strings as keys. In the case
+        // the empty key is expected to be the root package. If the root package
+        // has a prefix, then all other packages will as well (even if no other
+        // manifest represents them). The value is then saved as a separate value
+        let workspace_prefix = package_prefixes.remove("");
+
+        let package_prefixes = package_prefixes
+            .into_iter()
+            .map(|(k, v)| {
+                let prefix_path = PathBuf::from(v);
+                let prefix = prefix_path.parent().unwrap();
+                (k, prefix.to_string_lossy().to_string())
+            })
+            .collect();
+
+        Ok(Self {
+            sources,
+            workspace_prefix,
+            package_prefixes,
+        })
+    }
+
+    pub fn write_registry_urls(
+        lockfile: &cargo_lock::Lockfile,
+        manifest_path: &SplicedManifest,
+    ) -> Result<()> {
+        let mut manifest = read_manifest(manifest_path.as_path_buf())?;
+
+        let mut workspace_metaata = WorkspaceMetadata::try_from(
+            manifest
+                .workspace
+                .as_ref()
+                .unwrap()
+                .metadata
+                .as_ref()
+                .unwrap()
+                .clone(),
+        )?;
+
+        // Locate all packages soruced from a registry
+        let pkg_sources: Vec<&cargo_lock::Package> = lockfile
+            .packages
+            .iter()
+            .filter(|pkg| pkg.source.is_some())
+            .filter(|pkg| pkg.source.as_ref().unwrap().is_registry())
+            .collect();
+
+        // Collect a unique set of index urls
+        let index_urls: BTreeSet<String> = pkg_sources
+            .iter()
+            .map(|pkg| pkg.source.as_ref().unwrap().url().to_string())
+            .collect();
+
+        // Load the cargo config
+        let cargo_config = {
+            // Note that this path must match the one defined in `splicing::setup_cargo_config`
+            let config_path = manifest_path
+                .as_path_buf()
+                .parent()
+                .unwrap()
+                .join(".cargo")
+                .join("config.toml");
+
+            if config_path.exists() {
+                Some(CargoConfig::try_from_path(&config_path)?)
+            } else {
+                None
+            }
+        };
+
+        // Load each index for easy access
+        let crate_indexes = index_urls
+            .into_iter()
+            .map(|url| {
+                let index = {
+                    // Ensure the correct registry is mapped based on the give Cargo config.
+                    let index_url = if let Some(config) = &cargo_config {
+                        if let Some(source) = config.get_source_from_url(&url) {
+                            if let Some(replace_with) = &source.replace_with {
+                                if let Some(replacement) = config.get_registry_index_url_by_name(replace_with) {
+                                    replacement
+                                } else {
+                                    bail!("Tried to replace registry {} with registry named {} but didn't have metadata about the replacement", url, replace_with);
+                                }
+                            } else {
+                                &url
+                            }
+                        } else {
+                            &url
+                        }
+                    } else {
+                        &url
+                    };
+
+                    // Load the index for the current url
+                    let index = crates_index::Index::from_url(index_url)
+                        .with_context(|| format!("Failed to load index for url: {}", index_url))?;
+
+                    // Ensure each index has a valid index config
+                    index.index_config().with_context(|| {
+                        format!("`config.json` not found in index: {}", index_url)
+                    })?;
+
+                    index
+                };
+
+                Ok((url, index))
+            })
+            .collect::<Result<BTreeMap<String, crates_index::Index>>>()
+            .context("Failed to locate crate indexes")?;
+
+        // Get the download URL of each package based on it's registry url.
+        let additional_sources = pkg_sources
+            .iter()
+            .filter_map(|pkg| {
+                let source_id = pkg.source.as_ref().unwrap();
+                let index = &crate_indexes[&source_id.url().to_string()];
+                let index_config = index.index_config().unwrap();
+
+                index.crate_(pkg.name.as_str()).map(|crate_idx| {
+                    crate_idx
+                        .versions()
+                        .iter()
+                        .find(|v| v.version() == pkg.version.to_string())
+                        .and_then(|v| {
+                            v.download_url(&index_config).map(|url| {
+                                let crate_id =
+                                    CrateId::new(v.name().to_owned(), v.version().to_owned());
+                                let sha256 = pkg
+                                    .checksum
+                                    .as_ref()
+                                    .and_then(|sum| {
+                                        sum.as_sha256().map(|sum| sum.encode_hex::<String>())
+                                    })
+                                    .unwrap_or_else(|| v.checksum().encode_hex::<String>());
+                                let source_info = SourceInfo { url, sha256 };
+                                (crate_id, source_info)
+                            })
+                        })
+                })
+            })
+            .flatten();
+
+        workspace_metaata.sources.extend(additional_sources);
+        workspace_metaata.inject_into(&mut manifest)?;
+
+        write_root_manifest(manifest_path.as_path_buf(), manifest)?;
+
+        Ok(())
+    }
+
+    fn inject_into(&self, manifest: &mut Manifest) -> Result<()> {
+        let metadata_value = toml::Value::try_from(self)?;
+        let mut workspace = manifest.workspace.as_mut().unwrap();
+
+        match &mut workspace.metadata {
+            Some(data) => match data.as_table_mut() {
+                Some(map) => {
+                    map.insert("cargo-bazel".to_owned(), metadata_value);
+                }
+                None => bail!("The metadata field is always expected to be a table"),
+            },
+            None => {
+                let mut table = toml::map::Map::new();
+                table.insert("cargo-bazel".to_owned(), metadata_value);
+                workspace.metadata = Some(toml::Value::Table(table))
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum SplicedManifest {
+    Workspace(PathBuf),
+    Package(PathBuf),
+    MultiPackage(PathBuf),
+}
+
+impl SplicedManifest {
+    pub fn as_path_buf(&self) -> &PathBuf {
+        match self {
+            SplicedManifest::Workspace(p) => p,
+            SplicedManifest::Package(p) => p,
+            SplicedManifest::MultiPackage(p) => p,
+        }
+    }
+}
+
+pub fn read_manifest(manifest: &Path) -> Result<Manifest> {
+    let content = fs::read_to_string(manifest)?;
+    cargo_toml::Manifest::from_str(content.as_str()).context("Failed to deserialize manifest")
+}
+
+pub fn generate_lockfile(
+    manifest_path: &SplicedManifest,
+    existing_lock: &Option<PathBuf>,
+    cargo_bin: &Path,
+    rustc_bin: &Path,
+) -> Result<cargo_lock::Lockfile> {
+    let manifest_dir = manifest_path
+        .as_path_buf()
+        .parent()
+        .expect("Every manifest should be contained in a parent directory");
+
+    let root_lockfile_path = manifest_dir.join("Cargo.lock");
+
+    // Remove the file so it's not overwitten if it happens to be a symlink.
+    if root_lockfile_path.exists() {
+        fs::remove_file(&root_lockfile_path)?;
+    }
+
+    // Generate the new lockfile
+    let lockfile = LockGenerator::new(PathBuf::from(cargo_bin), PathBuf::from(rustc_bin))
+        .generate(manifest_path.as_path_buf(), existing_lock)?;
+
+    // Write the lockfile to disk
+    if !root_lockfile_path.exists() {
+        bail!("Failed to generate Cargo.lock file")
+    }
+
+    Ok(lockfile)
+}
diff --git a/third_party/rules_rust/crate_universe/src/splicing/cargo_config.rs b/third_party/rules_rust/crate_universe/src/splicing/cargo_config.rs
new file mode 100644
index 0000000..ffa42b7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/splicing/cargo_config.rs
@@ -0,0 +1,244 @@
+//! Tools for parsing [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html) files
+
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::Path;
+use std::str::FromStr;
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+/// The [`[registry]`](https://doc.rust-lang.org/cargo/reference/config.html#registry)
+/// table controls the default registry used when one is not specified.
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+pub struct Registry {
+    /// name of the default registry
+    pub default: String,
+
+    /// authentication token for crates.io
+    pub token: Option<String>,
+}
+
+/// The [`[source]`](https://doc.rust-lang.org/cargo/reference/config.html#source)
+/// table defines the registry sources available.
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+pub struct Source {
+    /// replace this source with the given named source
+    #[serde(rename = "replace-with")]
+    pub replace_with: Option<String>,
+
+    /// URL to a registry source
+    #[serde(default = "default_registry_url")]
+    pub registry: String,
+}
+
+/// This is the default registry url per what's defined by Cargo.
+fn default_registry_url() -> String {
+    "https://github.com/rust-lang/crates.io-index".to_owned()
+}
+
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+/// registries other than crates.io
+pub struct AdditionalRegistry {
+    /// URL of the registry index
+    pub index: String,
+
+    /// authentication token for the registry
+    pub token: Option<String>,
+}
+
+/// A subset of a Cargo configuration file. The schema here is only what
+/// is required for parsing registry information.
+/// See [cargo docs](https://doc.rust-lang.org/cargo/reference/config.html#configuration-format)
+/// for more details.
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+pub struct CargoConfig {
+    /// registries other than crates.io
+    #[serde(default = "default_registries")]
+    pub registries: BTreeMap<String, AdditionalRegistry>,
+
+    #[serde(default = "default_registry")]
+    pub registry: Registry,
+
+    /// source definition and replacement
+    #[serde(default = "BTreeMap::new")]
+    pub source: BTreeMap<String, Source>,
+}
+
+/// Each Cargo config is expected to have a default `crates-io` registry.
+fn default_registries() -> BTreeMap<String, AdditionalRegistry> {
+    let mut registries = BTreeMap::new();
+    registries.insert(
+        "crates-io".to_owned(),
+        AdditionalRegistry {
+            index: default_registry_url(),
+            token: None,
+        },
+    );
+    registries
+}
+
+/// Each Cargo config has a default registry for `crates.io`.
+fn default_registry() -> Registry {
+    Registry {
+        default: "crates-io".to_owned(),
+        token: None,
+    }
+}
+
+impl Default for CargoConfig {
+    fn default() -> Self {
+        let registries = default_registries();
+        let registry = default_registry();
+        let source = Default::default();
+
+        Self {
+            registries,
+            registry,
+            source,
+        }
+    }
+}
+
+impl FromStr for CargoConfig {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let incoming: CargoConfig = toml::from_str(s)?;
+        let mut config = Self::default();
+        config.registries.extend(incoming.registries);
+        config.source.extend(incoming.source);
+        config.registry = incoming.registry;
+        Ok(config)
+    }
+}
+
+impl CargoConfig {
+    /// Load a Cargo conig from a path to a file on disk.
+    pub fn try_from_path(path: &Path) -> Result<Self> {
+        let content = fs::read_to_string(path)?;
+        Self::from_str(&content)
+    }
+
+    /// Look up a reigstry [Source] by it's url.
+    pub fn get_source_from_url(&self, url: &str) -> Option<&Source> {
+        self.source.values().find(|v| v.registry == url)
+    }
+
+    pub fn get_registry_index_url_by_name(&self, name: &str) -> Option<&str> {
+        if let Some(registry) = self.registries.get(name) {
+            Some(&registry.index)
+        } else if let Some(source) = self.source.get(name) {
+            Some(&source.registry)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use std::fs;
+
+    #[test]
+    fn registry_settings() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let config = temp_dir.as_ref().join("config.toml");
+
+        fs::write(&config, textwrap::dedent(
+            r##"
+                # Makes artifactory the default registry and saves passing --registry parameter
+                [registry]
+                default = "art-crates-remote"
+                
+                [registries]
+                # Remote repository proxy in Artifactory (read-only)
+                art-crates-remote = { index = "https://artprod.mycompany/artifactory/git/cargo-remote.git" }
+                
+                # Optional, use with --registry to publish to crates.io
+                crates-io = { index = "https://github.com/rust-lang/crates.io-index" }
+
+                [net]
+                git-fetch-with-cli = true
+            "##,
+        )).unwrap();
+
+        let config = CargoConfig::try_from_path(&config).unwrap();
+        assert_eq!(
+            config,
+            CargoConfig {
+                registries: BTreeMap::from([
+                    (
+                        "art-crates-remote".to_owned(),
+                        AdditionalRegistry {
+                            index: "https://artprod.mycompany/artifactory/git/cargo-remote.git"
+                                .to_owned(),
+                            token: None,
+                        },
+                    ),
+                    (
+                        "crates-io".to_owned(),
+                        AdditionalRegistry {
+                            index: "https://github.com/rust-lang/crates.io-index".to_owned(),
+                            token: None,
+                        },
+                    ),
+                ]),
+                registry: Registry {
+                    default: "art-crates-remote".to_owned(),
+                    token: None,
+                },
+                source: BTreeMap::new(),
+            },
+        )
+    }
+
+    #[test]
+    fn registry_settings_get_index_url_by_name_from_source() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let config = temp_dir.as_ref().join("config.toml");
+
+        fs::write(&config, textwrap::dedent(
+            r##"
+                [registries]
+                art-crates-remote = { index = "https://artprod.mycompany/artifactory/git/cargo-remote.git" }
+
+                [source.crates-io]
+                replace-with = "some-mirror"
+
+                [source.some-mirror]
+                registry = "https://artmirror.mycompany/artifactory/cargo-mirror.git"
+            "##,
+        )).unwrap();
+
+        let config = CargoConfig::try_from_path(&config).unwrap();
+        assert_eq!(
+            config.get_registry_index_url_by_name("some-mirror"),
+            Some("https://artmirror.mycompany/artifactory/cargo-mirror.git"),
+        );
+    }
+
+    #[test]
+    fn registry_settings_get_index_url_by_name_from_registry() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let config = temp_dir.as_ref().join("config.toml");
+
+        fs::write(&config, textwrap::dedent(
+            r##"
+                [registries]
+                art-crates-remote = { index = "https://artprod.mycompany/artifactory/git/cargo-remote.git" }
+
+                [source.crates-io]
+                replace-with = "art-crates-remote"
+            "##,
+        )).unwrap();
+
+        let config = CargoConfig::try_from_path(&config).unwrap();
+        assert_eq!(
+            config.get_registry_index_url_by_name("art-crates-remote"),
+            Some("https://artprod.mycompany/artifactory/git/cargo-remote.git"),
+        );
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/splicing/splicer.rs b/third_party/rules_rust/crate_universe/src/splicing/splicer.rs
new file mode 100644
index 0000000..5e3ef27
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/splicing/splicer.rs
@@ -0,0 +1,1443 @@
+//! Utility for creating valid Cargo workspaces
+
+use std::collections::{BTreeSet, HashMap};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Context, Result};
+use cargo_toml::{Dependency, Manifest};
+
+use crate::config::CrateId;
+use crate::splicing::{SplicedManifest, SplicingManifest};
+use crate::utils::starlark::Label;
+
+use super::{
+    read_manifest, DirectPackageManifest, ExtraManifestInfo, ExtraManifestsManifest,
+    WorkspaceMetadata,
+};
+
+/// The core splicer implementation. Each style of Bazel workspace should be represented
+/// here and a splicing implementation defined.
+pub enum SplicerKind<'a> {
+    /// Splice a manifest which is represented by a Cargo workspace
+    Workspace {
+        path: &'a PathBuf,
+        manifest: &'a Manifest,
+        splicing_manifest: &'a SplicingManifest,
+        extra_manifests_manifest: &'a ExtraManifestsManifest,
+    },
+    /// Splice a manifest for a single package. This includes cases where
+    /// were defined directly in Bazel.
+    Package {
+        path: &'a PathBuf,
+        manifest: &'a Manifest,
+        splicing_manifest: &'a SplicingManifest,
+        extra_manifests_manifest: &'a ExtraManifestsManifest,
+    },
+    /// Splice a manifest from multiple disjoint Cargo manifests.
+    MultiPackage {
+        manifests: &'a HashMap<PathBuf, Manifest>,
+        splicing_manifest: &'a SplicingManifest,
+        extra_manifests_manifest: &'a ExtraManifestsManifest,
+    },
+}
+
+/// A list of files or directories to ignore when when symlinking
+const IGNORE_LIST: &[&str] = &[".git", "bazel-*", ".svn"];
+
+impl<'a> SplicerKind<'a> {
+    pub fn new(
+        manifests: &'a HashMap<PathBuf, Manifest>,
+        splicing_manifest: &'a SplicingManifest,
+        extra_manifests_manifest: &'a ExtraManifestsManifest,
+    ) -> Result<Self> {
+        // First check for any workspaces in the provided manifests
+        let workspace_owned: HashMap<&PathBuf, &Manifest> = manifests
+            .iter()
+            .filter(|(_, manifest)| is_workspace_owned(manifest))
+            .collect();
+
+        let mut root_workspace_pair: Option<(&PathBuf, &Manifest)> = None;
+
+        if !workspace_owned.is_empty() {
+            // Filter for the root workspace manifest info
+            let (mut workspace_roots, workspace_packages): (
+                HashMap<&PathBuf, &Manifest>,
+                HashMap<&PathBuf, &Manifest>,
+            ) = workspace_owned
+                .clone()
+                .into_iter()
+                .partition(|(_, manifest)| is_workspace_root(manifest));
+
+            if workspace_roots.len() > 1 {
+                bail!("When splicing manifests, there can only be 1 root workspace manifest");
+            }
+
+            // Ensure all workspace owned manifests are members of the one workspace root
+            let (root_manifest_path, root_manifest) = workspace_roots.drain().last().unwrap();
+            let external_workspace_members: BTreeSet<String> = workspace_packages
+                .into_iter()
+                .filter(|(manifest_path, _)| {
+                    !is_workspace_member(root_manifest, root_manifest_path, manifest_path)
+                })
+                .map(|(path, _)| path.to_string_lossy().to_string())
+                .collect();
+
+            if !external_workspace_members.is_empty() {
+                bail!("A package was provided that appears to be a part of another workspace.\nworkspace root: '{}'\nexternal packages: {:#?}", root_manifest_path.display(), external_workspace_members)
+            }
+
+            // Ensure all workspace members are present for the given workspace
+            let workspace_members = root_manifest.workspace.as_ref().unwrap().members.clone();
+            let missing_manifests: BTreeSet<String> = workspace_members
+                .into_iter()
+                .filter(|member| {
+                    // Check for any members that are missing from the list of manifests
+                    !manifests.keys().any(|path| {
+                        let path_str = path.to_string_lossy().to_string();
+                        // Account for windows paths.
+                        let path_str = path_str.replace("\\", "/");
+                        // Workspace members are represented as directories.
+                        path_str.trim_end_matches("/Cargo.toml").ends_with(member)
+                    })
+                })
+                .filter_map(|path_str| {
+                    // UNWRAP: Safe because a Cargo.toml file must have a parent directory.
+                    let cargo_manifest_dir = root_manifest_path.parent().unwrap();
+                    let label = Label::from_absolute_path(
+                        &cargo_manifest_dir.join(path_str).join("Cargo.toml"),
+                    );
+                    match label {
+                        Ok(label) => Some(label.to_string()),
+                        Err(err) => {
+                            eprintln!("Failed to identify label for missing manifest: {}", err);
+                            None
+                        }
+                    }
+                })
+                .collect();
+
+            if !missing_manifests.is_empty() {
+                bail!("Some manifests are not being tracked. Please add the following labels to the `manifests` key: {:#?}", missing_manifests)
+            }
+
+            root_workspace_pair = Some((root_manifest_path, root_manifest));
+        }
+
+        if let Some((path, manifest)) = root_workspace_pair {
+            Ok(Self::Workspace {
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            })
+        } else if manifests.len() == 1 {
+            let (path, manifest) = manifests.iter().last().unwrap();
+            Ok(Self::Package {
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            })
+        } else {
+            Ok(Self::MultiPackage {
+                manifests,
+                splicing_manifest,
+                extra_manifests_manifest,
+            })
+        }
+    }
+
+    /// Performs splicing based on the current variant.
+    pub fn splice(&self, workspace_dir: &Path) -> Result<SplicedManifest> {
+        match self {
+            SplicerKind::Workspace {
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            } => Self::splice_workspace(
+                workspace_dir,
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            ),
+            SplicerKind::Package {
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            } => Self::splice_package(
+                workspace_dir,
+                path,
+                manifest,
+                splicing_manifest,
+                extra_manifests_manifest,
+            ),
+            SplicerKind::MultiPackage {
+                manifests,
+                splicing_manifest,
+                extra_manifests_manifest,
+            } => Self::splice_multi_package(
+                workspace_dir,
+                manifests,
+                splicing_manifest,
+                extra_manifests_manifest,
+            ),
+        }
+    }
+
+    fn splice_workspace(
+        workspace_dir: &Path,
+        path: &&PathBuf,
+        manifest: &&Manifest,
+        splicing_manifest: &&SplicingManifest,
+        extra_manifests_manifest: &&ExtraManifestsManifest,
+    ) -> Result<SplicedManifest> {
+        let mut manifest = (*manifest).clone();
+        let manifest_dir = path
+            .parent()
+            .expect("Every manifest should havee a parent directory");
+
+        let extra_workspace_manifests =
+            Self::get_extra_workspace_manifests(&extra_manifests_manifest.manifests)?;
+
+        // Link the sources of the root manifest into the new workspace
+        symlink_roots(manifest_dir, workspace_dir, Some(IGNORE_LIST))?;
+
+        // Optionally install the cargo config after contents have been symlinked
+        Self::setup_cargo_config(&splicing_manifest.cargo_config, workspace_dir)?;
+
+        // Add additional workspace members to the new manifest
+        let mut installations = Self::inject_workspace_members(
+            &mut manifest,
+            &extra_workspace_manifests,
+            workspace_dir,
+        )?;
+
+        // Add any additional depeendencies to the root package
+        Self::inject_direct_packages(&mut manifest, &splicing_manifest.direct_packages)?;
+
+        let root_manifest_path = workspace_dir.join("Cargo.toml");
+        installations.insert(path, String::new());
+
+        // Write the generated metadata to the manifest
+        let workspace_metadata =
+            WorkspaceMetadata::new(splicing_manifest, extra_manifests_manifest, installations)?;
+        workspace_metadata.inject_into(&mut manifest)?;
+
+        // Write the root manifest
+        write_root_manifest(&root_manifest_path, manifest)?;
+
+        Ok(SplicedManifest::Workspace(root_manifest_path))
+    }
+
+    fn splice_package(
+        workspace_dir: &Path,
+        path: &&PathBuf,
+        manifest: &&Manifest,
+        splicing_manifest: &&SplicingManifest,
+        extra_manifests_manifest: &&ExtraManifestsManifest,
+    ) -> Result<SplicedManifest> {
+        let manifest_dir = path
+            .parent()
+            .expect("Every manifest should havee a parent directory");
+
+        let extra_workspace_manifests =
+            Self::get_extra_workspace_manifests(&extra_manifests_manifest.manifests)?;
+
+        // Link the sources of the root manifest into the new workspace
+        symlink_roots(manifest_dir, workspace_dir, Some(IGNORE_LIST))?;
+
+        // Optionally install the cargo config after contents have been symlinked
+        Self::setup_cargo_config(&splicing_manifest.cargo_config, workspace_dir)?;
+
+        // Ensure the root package manifest has a populated `workspace` member
+        let mut manifest = (*manifest).clone();
+        if manifest.workspace.is_none() {
+            manifest.workspace =
+                default_cargo_workspace_manifest(&splicing_manifest.resolver_version).workspace
+        }
+
+        // Add additional workspace members to the new manifest
+        let mut installations = Self::inject_workspace_members(
+            &mut manifest,
+            &extra_workspace_manifests,
+            workspace_dir,
+        )?;
+
+        // Add any additional depeendencies to the root package
+        Self::inject_direct_packages(&mut manifest, &splicing_manifest.direct_packages)?;
+
+        let root_manifest_path = workspace_dir.join("Cargo.toml");
+        installations.insert(path, String::new());
+
+        // Write the generated metadata to the manifest
+        let workspace_metadata =
+            WorkspaceMetadata::new(splicing_manifest, extra_manifests_manifest, installations)?;
+        workspace_metadata.inject_into(&mut manifest)?;
+
+        // Write the root manifest
+        write_root_manifest(&root_manifest_path, manifest)?;
+
+        Ok(SplicedManifest::Package(root_manifest_path))
+    }
+
+    fn splice_multi_package(
+        workspace_dir: &Path,
+        manifests: &&HashMap<PathBuf, Manifest>,
+        splicing_manifest: &&SplicingManifest,
+        extra_manifests_manifest: &&ExtraManifestsManifest,
+    ) -> Result<SplicedManifest> {
+        let mut manifest = default_cargo_workspace_manifest(&splicing_manifest.resolver_version);
+
+        // Optionally install a cargo config file into the workspace root.
+        Self::setup_cargo_config(&splicing_manifest.cargo_config, workspace_dir)?;
+
+        let extra_workspace_manifests =
+            Self::get_extra_workspace_manifests(&extra_manifests_manifest.manifests)?;
+
+        let manifests: HashMap<PathBuf, Manifest> = manifests
+            .iter()
+            .map(|(p, m)| (p.to_owned(), m.to_owned()))
+            .collect();
+
+        let all_manifests = manifests
+            .iter()
+            .chain(extra_workspace_manifests.iter())
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect();
+
+        let installations =
+            Self::inject_workspace_members(&mut manifest, &all_manifests, workspace_dir)?;
+
+        // Write the generated metadata to the manifest
+        let workspace_metadata =
+            WorkspaceMetadata::new(splicing_manifest, extra_manifests_manifest, installations)?;
+        workspace_metadata.inject_into(&mut manifest)?;
+
+        // Add any additional depeendencies to the root package
+        Self::inject_direct_packages(&mut manifest, &splicing_manifest.direct_packages)?;
+
+        // Write the root manifest
+        let root_manifest_path = workspace_dir.join("Cargo.toml");
+        write_root_manifest(&root_manifest_path, manifest)?;
+
+        Ok(SplicedManifest::MultiPackage(root_manifest_path))
+    }
+
+    /// Extract the set of extra workspace member manifests such that it matches
+    /// how other manifests are passed when creating a new [SplicerKind].
+    fn get_extra_workspace_manifests(
+        extra_manifests: &[ExtraManifestInfo],
+    ) -> Result<HashMap<PathBuf, Manifest>> {
+        extra_manifests
+            .iter()
+            .map(|config| match read_manifest(&config.manifest) {
+                Ok(manifest) => Ok((config.manifest.clone(), manifest)),
+                Err(err) => Err(err),
+            })
+            .collect()
+    }
+
+    /// A helper for installing Cargo config files into the spliced workspace while also
+    /// ensuring no other linked config file is available
+    fn setup_cargo_config(cargo_config_path: &Option<PathBuf>, workspace_dir: &Path) -> Result<()> {
+        // Make sure no other config files exist
+        for config in vec![
+            workspace_dir.join("config"),
+            workspace_dir.join("config.toml"),
+        ] {
+            if config.exists() {
+                fs::remove_file(&config).with_context(|| {
+                    format!(
+                        "Failed to delete existing cargo config: {}",
+                        config.display()
+                    )
+                })?;
+            }
+        }
+
+        // If the `.cargo` dir is a symlink, we'll need to relink it and ensure
+        // a Cargo config file is omitted
+        let dot_cargo_dir = workspace_dir.join(".cargo");
+        if dot_cargo_dir.exists() {
+            let is_symlink = dot_cargo_dir
+                .symlink_metadata()
+                .map(|m| m.file_type().is_symlink())
+                .unwrap_or(false);
+            if is_symlink {
+                let real_path = dot_cargo_dir.canonicalize()?;
+                remove_symlink(&dot_cargo_dir).with_context(|| {
+                    format!(
+                        "Failed to remove existing symlink {}",
+                        dot_cargo_dir.display()
+                    )
+                })?;
+                fs::create_dir(&dot_cargo_dir)?;
+                symlink_roots(&real_path, &dot_cargo_dir, Some(&["config", "config.toml"]))?;
+            } else {
+                for config in vec![
+                    dot_cargo_dir.join("config"),
+                    dot_cargo_dir.join("config.toml"),
+                ] {
+                    if config.exists() {
+                        fs::remove_file(&config)?;
+                    }
+                }
+            }
+        }
+
+        // Install the new config file after having removed all others
+        if let Some(cargo_config_path) = cargo_config_path {
+            if !dot_cargo_dir.exists() {
+                fs::create_dir_all(&dot_cargo_dir)?;
+            }
+
+            fs::copy(cargo_config_path, &dot_cargo_dir.join("config.toml"))?;
+        }
+
+        Ok(())
+    }
+
+    /// Update the newly generated manifest to include additional packages as
+    /// Cargo workspace members.
+    fn inject_workspace_members<'b>(
+        root_manifest: &mut Manifest,
+        manifests: &'b HashMap<PathBuf, Manifest>,
+        workspace_dir: &Path,
+    ) -> Result<HashMap<&'b PathBuf, String>> {
+        manifests
+            .iter()
+            .map(|(path, manifest)| {
+                let package_name = &manifest
+                    .package
+                    .as_ref()
+                    .expect("Each manifest should have a root package")
+                    .name;
+
+                root_manifest
+                    .workspace
+                    .as_mut()
+                    .expect("The root manifest is expected to always have a workspace")
+                    .members
+                    .push(package_name.clone());
+
+                let manifest_dir = path
+                    .parent()
+                    .expect("Every manifest should havee a parent directory");
+
+                let dest_package_dir = workspace_dir.join(package_name);
+
+                match symlink_roots(manifest_dir, &dest_package_dir, Some(IGNORE_LIST)) {
+                    Ok(_) => Ok((path, package_name.clone())),
+                    Err(e) => Err(e),
+                }
+            })
+            .collect()
+    }
+
+    fn inject_direct_packages(
+        manifest: &mut Manifest,
+        direct_packages_manifest: &DirectPackageManifest,
+    ) -> Result<()> {
+        // Ensure there's a root package to satisfy Cargo requirements
+        if manifest.package.is_none() {
+            let new_manifest = default_cargo_package_manifest();
+            manifest.package = new_manifest.package;
+            if manifest.lib.is_none() {
+                manifest.lib = new_manifest.lib;
+            }
+        }
+
+        // Check for any duplicates
+        let duplicates: Vec<&String> = manifest
+            .dependencies
+            .keys()
+            .filter(|k| direct_packages_manifest.contains_key(*k))
+            .collect();
+        if !duplicates.is_empty() {
+            bail!(
+                "Duplications detected between manifest dependencies and direct dependencies: {:?}",
+                duplicates
+            )
+        }
+
+        // Add the dependencies
+        for (name, details) in direct_packages_manifest.iter() {
+            manifest.dependencies.insert(
+                name.clone(),
+                cargo_toml::Dependency::Detailed(details.clone()),
+            );
+        }
+
+        Ok(())
+    }
+}
+
+pub struct Splicer {
+    workspace_dir: PathBuf,
+    manifests: HashMap<PathBuf, Manifest>,
+    splicing_manifest: SplicingManifest,
+    extra_manifests_manifest: ExtraManifestsManifest,
+}
+
+impl Splicer {
+    pub fn new(
+        workspace_dir: PathBuf,
+        splicing_manifest: SplicingManifest,
+        extra_manifests_manifest: ExtraManifestsManifest,
+    ) -> Result<Self> {
+        // Load all manifests
+        let manifests = splicing_manifest
+            .manifests
+            .iter()
+            .map(|(path, _)| {
+                let m = read_manifest(path)
+                    .with_context(|| format!("Failed to read manifest at {}", path.display()))?;
+                Ok((path.clone(), m))
+            })
+            .collect::<Result<HashMap<PathBuf, Manifest>>>()?;
+
+        Ok(Self {
+            workspace_dir,
+            manifests,
+            splicing_manifest,
+            extra_manifests_manifest,
+        })
+    }
+
+    /// Build a new workspace root
+    pub fn splice_workspace(&self) -> Result<SplicedManifest> {
+        SplicerKind::new(
+            &self.manifests,
+            &self.splicing_manifest,
+            &self.extra_manifests_manifest,
+        )?
+        .splice(&self.workspace_dir)
+    }
+}
+
+const DEFAULT_SPLICING_PACKAGE_NAME: &str = "direct-cargo-bazel-deps";
+const DEFAULT_SPLICING_PACKAGE_VERSION: &str = "0.0.1";
+
+pub fn default_cargo_package_manifest() -> cargo_toml::Manifest {
+    // A manifest is generated with a fake workspace member so the [cargo_toml::Manifest::Workspace]
+    // member is deseralized and is not `None`.
+    let manifest = cargo_toml::Manifest::from_str(
+        &toml::toml! {
+            [package]
+            name = DEFAULT_SPLICING_PACKAGE_NAME
+            version = DEFAULT_SPLICING_PACKAGE_VERSION
+            edition = "2018"
+
+            // A fake target used to satisfy requirements of Cargo.
+            [lib]
+            name = "direct_cargo_bazel_deps"
+            path = ".direct_cargo_bazel_deps.rs"
+        }
+        .to_string(),
+    )
+    .unwrap();
+
+    manifest
+}
+
+pub fn default_splicing_package_crate_id() -> CrateId {
+    CrateId::new(
+        DEFAULT_SPLICING_PACKAGE_NAME.to_string(),
+        DEFAULT_SPLICING_PACKAGE_VERSION.to_string(),
+    )
+}
+
+pub fn default_cargo_workspace_manifest(
+    resolver_version: &cargo_toml::Resolver,
+) -> cargo_toml::Manifest {
+    // A manifest is generated with a fake workspace member so the [cargo_toml::Manifest::Workspace]
+    // member is deseralized and is not `None`.
+    let mut manifest = cargo_toml::Manifest::from_str(&textwrap::dedent(&format!(
+        r#"
+            [workspace]
+            resolver = "{}"
+        "#,
+        resolver_version,
+    )))
+    .unwrap();
+
+    // Drop the temp workspace member
+    manifest.workspace.as_mut().unwrap().members.pop();
+
+    manifest
+}
+
+/// Determine whtether or not the manifest is a workspace root
+pub fn is_workspace_root(manifest: &Manifest) -> bool {
+    // Anything with any workspace data is considered a workspace
+    manifest.workspace.is_some()
+}
+
+/// Evaluates whether or not a manifest is considered a "workspace" manifest.
+/// See [Cargo workspaces](https://doc.rust-lang.org/cargo/reference/workspaces.html).
+pub fn is_workspace_owned(manifest: &Manifest) -> bool {
+    if is_workspace_root(manifest) {
+        return true;
+    }
+
+    // Additionally, anything that contains path dependencies is also considered a workspace
+    manifest.dependencies.iter().any(|(_, dep)| match dep {
+        Dependency::Detailed(dep) => dep.path.is_some(),
+        _ => false,
+    })
+}
+
+/// Determines whether or not a particular manifest is a workspace member to a given root manifest
+pub fn is_workspace_member(
+    root_manifest: &Manifest,
+    root_manifest_path: &Path,
+    manifest_path: &Path,
+) -> bool {
+    let members = match root_manifest.workspace.as_ref() {
+        Some(workspace) => &workspace.members,
+        None => return false,
+    };
+
+    let root_parent = root_manifest_path
+        .parent()
+        .expect("All manifest paths should have a parent");
+    let manifest_abs_path = root_parent.join(manifest_path);
+
+    members.iter().any(|member| {
+        let member_manifest_path = root_parent.join(member).join("Cargo.toml");
+        member_manifest_path == manifest_abs_path
+    })
+}
+
+pub fn write_root_manifest(path: &Path, manifest: cargo_toml::Manifest) -> Result<()> {
+    // Remove the file in case one exists already, preventing symlinked files
+    // from having their contents overwritten.
+    if path.exists() {
+        fs::remove_file(path)?;
+    }
+
+    // Ensure the directory exists
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    // TODO(https://gitlab.com/crates.rs/cargo_toml/-/issues/3)
+    let value = toml::Value::try_from(&manifest)?;
+    fs::write(path, toml::to_string(&value)?)
+        .context(format!("Failed to write manifest to {}", path.display()))
+}
+
+/// Create a symlink file on unix systems
+#[cfg(target_family = "unix")]
+fn symlink(src: &Path, dest: &Path) -> Result<(), std::io::Error> {
+    std::os::unix::fs::symlink(src, dest)
+}
+
+/// Create a symlink file on windows systems
+#[cfg(target_family = "windows")]
+fn symlink(src: &Path, dest: &Path) -> Result<(), std::io::Error> {
+    if src.is_dir() {
+        std::os::windows::fs::symlink_dir(src, dest)
+    } else {
+        std::os::windows::fs::symlink_file(src, dest)
+    }
+}
+
+/// Create a symlink file on unix systems
+#[cfg(target_family = "unix")]
+fn remove_symlink(path: &Path) -> Result<(), std::io::Error> {
+    fs::remove_file(path)
+}
+
+/// Create a symlink file on windows systems
+#[cfg(target_family = "windows")]
+fn remove_symlink(path: &Path) -> Result<(), std::io::Error> {
+    if path.is_dir() {
+        fs::remove_dir(path)
+    } else {
+        fs::remove_file(path)
+    }
+}
+
+/// Symlinks the root contents of a source directory into a destination directory
+pub fn symlink_roots(source: &Path, dest: &Path, ignore_list: Option<&[&str]>) -> Result<()> {
+    // Ensure the source exists and is a directory
+    if !source.is_dir() {
+        bail!("Source path is not a directory: {}", source.display());
+    }
+
+    // Only check if the dest is a directory if it already exists
+    if dest.exists() && !dest.is_dir() {
+        bail!("Dest path is not a directory: {}", dest.display());
+    }
+
+    fs::create_dir_all(dest)?;
+
+    // Link each directory entry from the source dir to the dest
+    for entry in (source.read_dir()?).flatten() {
+        let basename = entry.file_name();
+
+        // Ignore certain directories that may lead to confusion
+        if let Some(base_str) = basename.to_str() {
+            if let Some(list) = ignore_list {
+                for item in list.iter() {
+                    // Handle optional glob patterns here. This allows us to ignore `bazel-*` patterns.
+                    if item.ends_with('*') && base_str.starts_with(item.trim_end_matches('*')) {
+                        continue;
+                    }
+
+                    // Finally, simply compare the string
+                    if *item == base_str {
+                        continue;
+                    }
+                }
+            }
+        }
+
+        let link_src = source.join(&basename);
+        let link_dest = dest.join(&basename);
+        symlink(&link_src, &link_dest).context(format!(
+            "Failed to create symlink: {} -> {}",
+            link_src.display(),
+            link_dest.display()
+        ))?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use std::fs;
+    use std::fs::File;
+    use std::str::FromStr;
+
+    use cargo_metadata::{MetadataCommand, PackageId};
+
+    use crate::splicing::ExtraManifestInfo;
+    use crate::utils::starlark::Label;
+
+    /// Clone and compare two items after calling `.sort()` on them.
+    macro_rules! assert_sort_eq {
+        ($left:expr, $right:expr $(,)?) => {
+            let mut left = $left.clone();
+            left.sort();
+            let mut right = $right.clone();
+            right.sort();
+            assert_eq!(left, right);
+        };
+    }
+
+    /// Get cargo and rustc binaries the Bazel way
+    #[cfg(not(feature = "cargo"))]
+    fn get_cargo_and_rustc_paths() -> (PathBuf, PathBuf) {
+        let runfiles = runfiles::Runfiles::create().unwrap();
+        let cargo_path = runfiles.rlocation(concat!("rules_rust/", env!("CARGO")));
+        let rustc_path = runfiles.rlocation(concat!("rules_rust/", env!("RUSTC")));
+
+        (cargo_path, rustc_path)
+    }
+
+    /// Get cargo and rustc binaries the Cargo way
+    #[cfg(feature = "cargo")]
+    fn get_cargo_and_rustc_paths() -> (PathBuf, PathBuf) {
+        (PathBuf::from("cargo"), PathBuf::from("rustc"))
+    }
+
+    fn generate_metadata(manifest_path: &Path) -> cargo_metadata::Metadata {
+        let manifest_dir = manifest_path.parent().unwrap_or_else(|| {
+            panic!(
+                "The given manifest has no parent directory: {}",
+                manifest_path.display()
+            )
+        });
+
+        let (cargo_path, rustc_path) = get_cargo_and_rustc_paths();
+
+        let output = MetadataCommand::new()
+            .cargo_path(cargo_path)
+            // Cargo detects config files based on `pwd` when running so
+            // to ensure user provided Cargo config files are used, it's
+            // critical to set the working directory to the manifest dir.
+            .current_dir(manifest_dir)
+            .manifest_path(manifest_path)
+            .other_options(["--offline".to_owned()])
+            .cargo_command()
+            .env("RUSTC", rustc_path)
+            .output()
+            .unwrap();
+
+        if !output.status.success() {
+            eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+            assert!(output.status.success());
+        }
+
+        let stdout = String::from_utf8(output.stdout).unwrap();
+
+        assert!(stdout
+            .lines()
+            .find(|line| line.starts_with('{'))
+            .ok_or(cargo_metadata::Error::NoJson)
+            .is_ok());
+
+        MetadataCommand::parse(stdout).unwrap()
+    }
+
+    fn mock_cargo_toml(path: &Path, name: &str) -> cargo_toml::Manifest {
+        let manifest = cargo_toml::Manifest::from_str(&textwrap::dedent(&format!(
+            r#"
+            [package]
+            name = "{}"
+            version = "0.0.1"
+
+            [lib]
+            path = "lib.rs"
+            "#,
+            name
+        )))
+        .unwrap();
+
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        fs::write(path, toml::to_string(&manifest).unwrap()).unwrap();
+
+        manifest
+    }
+
+    fn mock_extra_manifest_digest(cache_dir: &Path) -> ExtraManifestsManifest {
+        ExtraManifestsManifest {
+            manifests: vec![{
+                let manifest_path = cache_dir.join("extra_pkg").join("Cargo.toml");
+                mock_cargo_toml(&manifest_path, "extra_pkg");
+
+                ExtraManifestInfo {
+                    manifest: manifest_path,
+                    url: "https://crates.io/".to_owned(),
+                    sha256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                        .to_owned(),
+                }
+            }],
+        }
+    }
+
+    /// This json object is tightly coupled to [mock_extra_manifest_digest]
+    fn mock_workspace_metadata(
+        include_extra_member: bool,
+        workspace_prefix: Option<&str>,
+    ) -> serde_json::Value {
+        let mut obj = if include_extra_member {
+            serde_json::json!({
+                "cargo-bazel": {
+                    "package_prefixes": {},
+                    "sources": {
+                        "extra_pkg 0.0.1": {
+                            "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+                            "url": "https://crates.io/"
+                        }
+                    }
+                }
+            })
+        } else {
+            serde_json::json!({
+                "cargo-bazel": {
+                    "package_prefixes": {},
+                    "sources": {}
+                }
+            })
+        };
+        if let Some(workspace_prefix) = workspace_prefix {
+            obj.as_object_mut().unwrap()["cargo-bazel"]
+                .as_object_mut()
+                .unwrap()
+                .insert("workspace_prefix".to_owned(), workspace_prefix.into());
+        }
+        obj
+    }
+
+    fn mock_splicing_manifest_with_workspace() -> (SplicingManifest, tempfile::TempDir) {
+        let mut splicing_manifest = SplicingManifest::default();
+        let cache_dir = tempfile::tempdir().unwrap();
+
+        // Write workspace members
+        for pkg in &["sub_pkg_a", "sub_pkg_b"] {
+            let manifest_path = cache_dir
+                .as_ref()
+                .join("root_pkg")
+                .join(pkg)
+                .join("Cargo.toml");
+            mock_cargo_toml(&manifest_path, pkg);
+
+            splicing_manifest.manifests.insert(
+                manifest_path,
+                Label::from_str(&format!("//{}:Cargo.toml", pkg)).unwrap(),
+            );
+        }
+
+        // Create the root package with a workspace definition
+        let manifest: cargo_toml::Manifest = toml::toml! {
+            [workspace]
+            members = [
+                "sub_pkg_a",
+                "sub_pkg_b",
+            ]
+            [package]
+            name = "root_pkg"
+            version = "0.0.1"
+
+            [lib]
+            path = "lib.rs"
+        }
+        .try_into()
+        .unwrap();
+
+        let workspace_root = cache_dir.as_ref();
+        {
+            File::create(workspace_root.join("WORKSPACE.bazel")).unwrap();
+        }
+        let root_pkg = workspace_root.join("root_pkg");
+        let manifest_path = root_pkg.join("Cargo.toml");
+        fs::create_dir_all(&manifest_path.parent().unwrap()).unwrap();
+        fs::write(&manifest_path, toml::to_string(&manifest).unwrap()).unwrap();
+
+        let sub_pkg_a = root_pkg.join("sub_pkg_a");
+        let sub_pkg_b = root_pkg.join("sub_pkg_b");
+        {
+            fs::create_dir_all(&sub_pkg_a).unwrap();
+            File::create(sub_pkg_a.join("BUILD.bazel")).unwrap();
+
+            fs::create_dir_all(&sub_pkg_b).unwrap();
+            File::create(sub_pkg_b.join("BUILD.bazel")).unwrap();
+        }
+
+        splicing_manifest.manifests.insert(
+            manifest_path,
+            Label::from_str("//pkg_root:Cargo.toml").unwrap(),
+        );
+
+        (splicing_manifest, cache_dir)
+    }
+
+    fn mock_splicing_manifest_with_workspace_in_root() -> (SplicingManifest, tempfile::TempDir) {
+        let mut splicing_manifest = SplicingManifest::default();
+        let cache_dir = tempfile::tempdir().unwrap();
+
+        // Write workspace members
+        for pkg in &["sub_pkg_a", "sub_pkg_b"] {
+            let manifest_path = cache_dir.as_ref().join(pkg).join("Cargo.toml");
+            mock_cargo_toml(&manifest_path, pkg);
+
+            splicing_manifest.manifests.insert(
+                manifest_path,
+                Label::from_str(&format!("//{}:Cargo.toml", pkg)).unwrap(),
+            );
+        }
+
+        // Create the root package with a workspace definition
+        let manifest: cargo_toml::Manifest = toml::toml! {
+            [workspace]
+            members = [
+                "sub_pkg_a",
+                "sub_pkg_b",
+            ]
+            [package]
+            name = "root_pkg"
+            version = "0.0.1"
+
+            [lib]
+            path = "lib.rs"
+        }
+        .try_into()
+        .unwrap();
+
+        let workspace_root = cache_dir.as_ref();
+        {
+            File::create(workspace_root.join("WORKSPACE.bazel")).unwrap();
+        }
+        let manifest_path = workspace_root.join("Cargo.toml");
+        fs::create_dir_all(&manifest_path.parent().unwrap()).unwrap();
+        fs::write(&manifest_path, toml::to_string(&manifest).unwrap()).unwrap();
+
+        let sub_pkg_a = workspace_root.join("sub_pkg_a");
+        let sub_pkg_b = workspace_root.join("sub_pkg_b");
+        {
+            fs::create_dir_all(&sub_pkg_a).unwrap();
+            File::create(sub_pkg_a.join("BUILD.bazel")).unwrap();
+
+            fs::create_dir_all(&sub_pkg_b).unwrap();
+            File::create(sub_pkg_b.join("BUILD.bazel")).unwrap();
+        }
+
+        splicing_manifest
+            .manifests
+            .insert(manifest_path, Label::from_str("//:Cargo.toml").unwrap());
+
+        (splicing_manifest, cache_dir)
+    }
+
+    fn mock_splicing_manifest_with_package() -> (SplicingManifest, tempfile::TempDir) {
+        let mut splicing_manifest = SplicingManifest::default();
+        let cache_dir = tempfile::tempdir().unwrap();
+
+        // Add an additional package
+        let manifest_path = cache_dir.as_ref().join("root_pkg").join("Cargo.toml");
+        mock_cargo_toml(&manifest_path, "root_pkg");
+        splicing_manifest
+            .manifests
+            .insert(manifest_path, Label::from_str("//:Cargo.toml").unwrap());
+
+        (splicing_manifest, cache_dir)
+    }
+
+    fn mock_splicing_manifest_with_multi_package() -> (SplicingManifest, tempfile::TempDir) {
+        let mut splicing_manifest = SplicingManifest::default();
+        let cache_dir = tempfile::tempdir().unwrap();
+
+        // Add an additional package
+        for pkg in &["pkg_a", "pkg_b", "pkg_c"] {
+            let manifest_path = cache_dir.as_ref().join(pkg).join("Cargo.toml");
+            mock_cargo_toml(&manifest_path, pkg);
+            splicing_manifest
+                .manifests
+                .insert(manifest_path, Label::from_str("//:Cargo.toml").unwrap());
+        }
+
+        (splicing_manifest, cache_dir)
+    }
+
+    fn new_package_id(name: &str, workspace_root: &Path, is_root: bool) -> PackageId {
+        let mut workspace_root = workspace_root.display().to_string();
+
+        // On windows, make sure we normalize the path to match what Cargo would
+        // otherwise use to populate metadata.
+        if cfg!(target_os = "windows") {
+            workspace_root = format!("/{}", workspace_root.replace("\\", "/"))
+        };
+
+        if is_root {
+            PackageId {
+                repr: format!("{} 0.0.1 (path+file://{})", name, workspace_root),
+            }
+        } else {
+            PackageId {
+                repr: format!("{} 0.0.1 (path+file://{}/{})", name, workspace_root, name,),
+            }
+        }
+    }
+
+    #[test]
+    fn splice_workspace() {
+        let (splicing_manifest, _cache_dir) = mock_splicing_manifest_with_workspace_in_root();
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("sub_pkg_a", workspace_root.as_ref(), false),
+                new_package_id("sub_pkg_b", workspace_root.as_ref(), false),
+                new_package_id("root_pkg", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(false, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn splice_workspace_in_root() {
+        let (splicing_manifest, _cache_dir) = mock_splicing_manifest_with_workspace_in_root();
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("sub_pkg_a", workspace_root.as_ref(), false),
+                new_package_id("sub_pkg_b", workspace_root.as_ref(), false),
+                new_package_id("root_pkg", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(false, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn splice_workspace_report_missing_members() {
+        let (mut splicing_manifest, _cache_dir) = mock_splicing_manifest_with_workspace();
+
+        // Remove everything but the root manifest
+        splicing_manifest
+            .manifests
+            .retain(|_, label| *label == Label::from_str("//pkg_root:Cargo.toml").unwrap());
+        assert_eq!(splicing_manifest.manifests.len(), 1);
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace();
+
+        assert!(workspace_manifest.is_err());
+
+        // Ensure both the missing manifests are mentioned in the error string
+        let err_str = format!("{:?}", &workspace_manifest);
+        assert!(
+            err_str.contains("Some manifests are not being tracked")
+                && err_str.contains("//root_pkg/sub_pkg_a:Cargo.toml")
+                && err_str.contains("//root_pkg/sub_pkg_b:Cargo.toml")
+        );
+    }
+
+    #[test]
+    fn splice_workspace_report_external_workspace_members() {
+        let (mut splicing_manifest, _cache_dir) = mock_splicing_manifest_with_workspace();
+
+        // Add a new package from an existing external workspace
+        let external_workspace_root = tempfile::tempdir().unwrap();
+        let external_manifest = external_workspace_root
+            .as_ref()
+            .join("external_workspace_member")
+            .join("Cargo.toml");
+        fs::create_dir_all(external_manifest.parent().unwrap()).unwrap();
+        fs::write(
+            &external_manifest,
+            &textwrap::dedent(
+                r#"
+                [package]
+                name = "external_workspace_member"
+                version = "0.0.1"
+
+                [lib]
+                path = "lib.rs"
+
+                [dependencies]
+                neighbor = { path = "../neighbor" }
+                "#,
+            ),
+        )
+        .unwrap();
+
+        splicing_manifest.manifests.insert(
+            external_manifest.clone(),
+            Label::from_str("@remote_dep//external_workspace_member:Cargo.toml").unwrap(),
+        );
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace();
+
+        assert!(workspace_manifest.is_err());
+
+        // Ensure both the external workspace member
+        let err_str = format!("{:?}", &workspace_manifest);
+        let bytes_str = format!("{:?}", external_manifest.to_string_lossy());
+        assert!(
+            err_str
+                .contains("A package was provided that appears to be a part of another workspace.")
+                && err_str.contains(&bytes_str)
+        );
+    }
+
+    #[test]
+    fn splice_package() {
+        let (splicing_manifest, _cache_dir) = mock_splicing_manifest_with_package();
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![new_package_id("root_pkg", workspace_root.as_ref(), true)]
+        );
+
+        // Ensure the workspace metadata annotations are not populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(false, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn splice_multi_package() {
+        let (splicing_manifest, _cache_dir) = mock_splicing_manifest_with_multi_package();
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Check the default resolver version
+        let cargo_manifest = cargo_toml::Manifest::from_str(
+            &fs::read_to_string(workspace_manifest.as_path_buf()).unwrap(),
+        )
+        .unwrap();
+        assert!(cargo_manifest.workspace.is_some());
+        assert_eq!(
+            cargo_manifest.workspace.unwrap().resolver,
+            Some(cargo_toml::Resolver::V1)
+        );
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("pkg_a", workspace_root.as_ref(), false),
+                new_package_id("pkg_b", workspace_root.as_ref(), false),
+                new_package_id("pkg_c", workspace_root.as_ref(), false),
+                // Multi package renderings always add a root package
+                new_package_id("direct-cargo-bazel-deps", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(false, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn splice_multi_package_with_resolver() {
+        let (mut splicing_manifest, _cache_dir) = mock_splicing_manifest_with_multi_package();
+
+        // Update the resolver version
+        splicing_manifest.resolver_version = cargo_toml::Resolver::V2;
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            ExtraManifestsManifest::default(),
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Check the specified resolver version
+        let cargo_manifest = cargo_toml::Manifest::from_str(
+            &fs::read_to_string(workspace_manifest.as_path_buf()).unwrap(),
+        )
+        .unwrap();
+        assert!(cargo_manifest.workspace.is_some());
+        assert_eq!(
+            cargo_manifest.workspace.unwrap().resolver,
+            Some(cargo_toml::Resolver::V2)
+        );
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("pkg_a", workspace_root.as_ref(), false),
+                new_package_id("pkg_b", workspace_root.as_ref(), false),
+                new_package_id("pkg_c", workspace_root.as_ref(), false),
+                // Multi package renderings always add a root package
+                new_package_id("direct-cargo-bazel-deps", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(false, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn extra_workspace_member_with_package() {
+        let (splicing_manifest, cache_dir) = mock_splicing_manifest_with_package();
+
+        // Add the extra workspace member
+        let extra_manifests_manifest = mock_extra_manifest_digest(cache_dir.as_ref());
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            extra_manifests_manifest,
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("extra_pkg", workspace_root.as_ref(), false),
+                new_package_id("root_pkg", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(true, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn extra_workspace_member_with_workspace() {
+        let (splicing_manifest, cache_dir) = mock_splicing_manifest_with_workspace();
+
+        // Add the extra workspace member
+        let extra_manifests_manifest = mock_extra_manifest_digest(cache_dir.as_ref());
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            extra_manifests_manifest,
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("sub_pkg_a", workspace_root.as_ref(), false),
+                new_package_id("sub_pkg_b", workspace_root.as_ref(), false),
+                new_package_id("extra_pkg", workspace_root.as_ref(), false),
+                new_package_id("root_pkg", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(true, Some("pkg_root"))
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+
+    #[test]
+    fn extra_workspace_member_with_multi_package() {
+        let (splicing_manifest, cache_dir) = mock_splicing_manifest_with_multi_package();
+
+        // Add the extra workspace member
+        let extra_manifests_manifest = mock_extra_manifest_digest(cache_dir.as_ref());
+
+        // Splice the workspace
+        let workspace_root = tempfile::tempdir().unwrap();
+        let workspace_manifest = Splicer::new(
+            workspace_root.as_ref().to_path_buf(),
+            splicing_manifest,
+            extra_manifests_manifest,
+        )
+        .unwrap()
+        .splice_workspace()
+        .unwrap();
+
+        // Ensure metadata is valid
+        let metadata = generate_metadata(workspace_manifest.as_path_buf());
+        assert_sort_eq!(
+            metadata.workspace_members,
+            vec![
+                new_package_id("pkg_a", workspace_root.as_ref(), false),
+                new_package_id("pkg_b", workspace_root.as_ref(), false),
+                new_package_id("pkg_c", workspace_root.as_ref(), false),
+                new_package_id("extra_pkg", workspace_root.as_ref(), false),
+                // Multi package renderings always add a root package
+                new_package_id("direct-cargo-bazel-deps", workspace_root.as_ref(), true),
+            ]
+        );
+
+        // Ensure the workspace metadata annotations are populated
+        assert_eq!(
+            metadata.workspace_metadata,
+            mock_workspace_metadata(true, None)
+        );
+
+        // Ensure lockfile was successfully spliced
+        cargo_lock::Lockfile::load(workspace_root.as_ref().join("Cargo.lock")).unwrap();
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/test.rs b/third_party/rules_rust/crate_universe/src/test.rs
new file mode 100644
index 0000000..5b67351
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/test.rs
@@ -0,0 +1,153 @@
+//! A module containing common test helpers
+
+pub fn mock_cargo_metadata_package() -> cargo_metadata::Package {
+    serde_json::from_value(serde_json::json!({
+        "name": "mock-pkg",
+        "version": "3.3.3",
+        "id": "mock-pkg 3.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+        "license": "Unlicense/MIT",
+        "license_file": null,
+        "description": "Fast multiple substring searching.",
+        "source": "registry+https://github.com/rust-lang/crates.io-index",
+        "dependencies": [],
+        "targets": [],
+        "features": {},
+        "manifest_path": "/tmp/mock-pkg-3.3.3/Cargo.toml",
+        "metadata": null,
+        "publish": null,
+        "authors": [],
+        "categories": [],
+        "keywords": [],
+        "readme": "README.md",
+        "repository": "",
+        "homepage": "",
+        "documentation": null,
+        "edition": "2021",
+        "links": null,
+        "default_run": null
+    }))
+    .unwrap()
+}
+
+pub fn mock_cargo_lock_package() -> cargo_lock::Package {
+    toml::from_str(&textwrap::dedent(
+        r#"
+        name = "mock-pkg"
+        version = "3.3.3"
+        source = "registry+https://github.com/rust-lang/crates.io-index"
+        checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+        dependencies = []
+        "#,
+    ))
+    .unwrap()
+}
+
+pub mod metadata {
+    pub fn alias() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/aliases/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn build_scripts() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/build_scripts/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn crate_types() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/crate_types/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn multi_cfg_dep() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/multi_cfg_dep/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn no_deps() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/no_deps/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn common() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/common/metadata.json"
+        )))
+        .unwrap()
+    }
+
+    pub fn git_repos() -> cargo_metadata::Metadata {
+        serde_json::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/git_repos/metadata.json"
+        )))
+        .unwrap()
+    }
+}
+
+pub mod lockfile {
+    use std::str::FromStr;
+
+    pub fn alias() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/aliases/Cargo.lock"
+        )))
+        .unwrap()
+    }
+
+    pub fn build_scripts() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/build_scripts/Cargo.lock"
+        )))
+        .unwrap()
+    }
+
+    pub fn crate_types() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/crate_types/Cargo.lock"
+        )))
+        .unwrap()
+    }
+
+    pub fn no_deps() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/no_deps/Cargo.lock"
+        )))
+        .unwrap()
+    }
+
+    pub fn common() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/common/Cargo.lock"
+        )))
+        .unwrap()
+    }
+
+    pub fn git_repos() -> cargo_lock::Lockfile {
+        cargo_lock::Lockfile::from_str(include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/test_data/metadata/git_repos/Cargo.lock"
+        )))
+        .unwrap()
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/utils.rs b/third_party/rules_rust/crate_universe/src/utils.rs
new file mode 100644
index 0000000..8953c81
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/utils.rs
@@ -0,0 +1,15 @@
+//! Common utilities
+
+pub mod starlark;
+
+/// Convert a string into a valid crate module name by applying transforms to invalid characters
+pub fn sanitize_module_name(name: &str) -> String {
+    name.replace('-', "_")
+}
+
+/// Some character which may be present in version IDs are not valid
+/// in Bazel repository names. This converts invalid characters. See
+/// [RepositoryName.java](https://github.com/bazelbuild/bazel/blob/4.0.0/src/main/java/com/google/devtools/build/lib/cmdline/RepositoryName.java#L42)
+pub fn sanitize_repository_name(name: &str) -> String {
+    name.replace('+', "-")
+}
diff --git a/third_party/rules_rust/crate_universe/src/utils/starlark.rs b/third_party/rules_rust/crate_universe/src/utils/starlark.rs
new file mode 100644
index 0000000..57007b7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/utils/starlark.rs
@@ -0,0 +1,12 @@
+//! A module for representations of starlark constructs
+
+mod glob;
+mod label;
+mod select;
+
+pub use glob::*;
+pub use label::*;
+pub use select::*;
+
+pub type SelectStringList = SelectList<String>;
+pub type SelectStringDict = SelectDict<String>;
diff --git a/third_party/rules_rust/crate_universe/src/utils/starlark/glob.rs b/third_party/rules_rust/crate_universe/src/utils/starlark/glob.rs
new file mode 100644
index 0000000..23b17a5
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/utils/starlark/glob.rs
@@ -0,0 +1,16 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, Clone)]
+pub struct Glob {
+    pub include: Vec<String>,
+    pub exclude: Vec<String>,
+}
+
+impl Glob {
+    pub fn new_rust_srcs() -> Self {
+        Self {
+            include: vec!["**/*.rs".to_owned()],
+            ..Default::default()
+        }
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/utils/starlark/label.rs b/third_party/rules_rust/crate_universe/src/utils/starlark/label.rs
new file mode 100644
index 0000000..1716944
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/utils/starlark/label.rs
@@ -0,0 +1,317 @@
+use std::fmt::{self, Display};
+use std::path::Path;
+use std::str::FromStr;
+
+use anyhow::{anyhow, bail, Context, Result};
+use regex::Regex;
+use serde::de::Visitor;
+use serde::{Deserialize, Serialize, Serializer};
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct Label {
+    pub repository: Option<String>,
+    pub package: Option<String>,
+    pub target: String,
+}
+
+impl FromStr for Label {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let re = Regex::new(r"^(@[\w\d\-_\.]*)?/{0,2}([\w\d\-_\./]+)?:?([\+\w\d\-_\./]+)$")?;
+        let cap = re
+            .captures(s)
+            .with_context(|| format!("Failed to parse label from string: {}", s))?;
+
+        let repository = cap
+            .get(1)
+            .map(|m| m.as_str().trim_start_matches('@').to_owned());
+        let package = cap.get(2).map(|m| m.as_str().to_owned());
+        let mut target = cap.get(3).map(|m| m.as_str().to_owned());
+
+        if target.is_none() {
+            if let Some(pkg) = &package {
+                target = Some(pkg.clone());
+            } else if let Some(repo) = &repository {
+                target = Some(repo.clone())
+            } else {
+                bail!("The label is missing a label")
+            }
+        }
+
+        // The target should be set at this point
+        let target = target.unwrap();
+
+        Ok(Self {
+            repository,
+            package,
+            target,
+        })
+    }
+}
+
+impl Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut label = String::new();
+
+        // Add the repository
+        if let Some(repo) = &self.repository {
+            label = format!("@{}", repo);
+        }
+
+        // Add the package
+        if let Some(pkg) = &self.package {
+            label = format!("{}//{}", label, pkg);
+        }
+
+        write!(f, "{}:{}", &label, &self.target,)
+    }
+}
+
+impl Label {
+    /// Generates a label appropriate for the passed Path by walking the filesystem to identify its
+    /// workspace and package.
+    pub fn from_absolute_path(p: &Path) -> Result<Self, anyhow::Error> {
+        let mut workspace_root = None;
+        let mut package_root = None;
+        for ancestor in p.ancestors().skip(1) {
+            if package_root.is_none()
+                && (ancestor.join("BUILD").exists() || ancestor.join("BUILD.bazel").exists())
+            {
+                package_root = Some(ancestor);
+            }
+            if workspace_root.is_none()
+                && (ancestor.join("WORKSPACE").exists()
+                    || ancestor.join("WORKSPACE.bazel").exists())
+            {
+                workspace_root = Some(ancestor);
+                break;
+            }
+        }
+        match (workspace_root, package_root) {
+            (Some(workspace_root), Some(package_root)) => {
+                // These unwraps are safe by construction of the ancestors and prefix calls which set up these paths.
+                let target = p.strip_prefix(package_root).unwrap();
+                let workspace_relative = p.strip_prefix(workspace_root).unwrap();
+                let mut package_path = workspace_relative.to_path_buf();
+                for _ in target.components() {
+                    package_path.pop();
+                }
+
+                let package = if package_path.components().count() > 0 {
+                    Some(path_to_label_part(&package_path)?)
+                } else {
+                    None
+                };
+                let target = path_to_label_part(target)?;
+
+                Ok(Label {
+                    repository: None,
+                    package,
+                    target,
+                })
+            }
+            (Some(_workspace_root), None) => {
+                bail!(
+                    "Could not identify package for path {}. Maybe you need to add a BUILD.bazel file.",
+                    p.display()
+                );
+            }
+            _ => {
+                bail!("Could not identify workspace for path {}", p.display());
+            }
+        }
+    }
+}
+
+/// Converts a path to a forward-slash-delimited label-appropriate path string.
+fn path_to_label_part(path: &Path) -> Result<String, anyhow::Error> {
+    let components: Result<Vec<_>, _> = path
+        .components()
+        .map(|c| {
+            c.as_os_str().to_str().ok_or_else(|| {
+                anyhow!(
+                    "Found non-UTF8 component turning path into label: {}",
+                    path.display()
+                )
+            })
+        })
+        .collect();
+    Ok(components?.join("/"))
+}
+
+impl Serialize for Label {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.repr())
+    }
+}
+
+struct LabelVisitor;
+impl<'de> Visitor<'de> for LabelVisitor {
+    type Value = Label;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("Expected string value of `{name} {version}`.")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Label::from_str(v).map_err(E::custom)
+    }
+}
+
+impl<'de> Deserialize<'de> for Label {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_str(LabelVisitor)
+    }
+}
+
+impl Label {
+    pub fn repr(&self) -> String {
+        self.to_string()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use spectral::prelude::*;
+    use std::fs::{create_dir_all, File};
+    use tempfile::tempdir;
+
+    #[test]
+    fn full_label() {
+        let label = Label::from_str("@repo//package/sub_package:target").unwrap();
+        assert_eq!(label.repository.unwrap(), "repo");
+        assert_eq!(label.package.unwrap(), "package/sub_package");
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn no_repository() {
+        let label = Label::from_str("//package:target").unwrap();
+        assert_eq!(label.repository, None);
+        assert_eq!(label.package.unwrap(), "package");
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn no_slashes() {
+        let label = Label::from_str("package:target").unwrap();
+        assert_eq!(label.repository, None);
+        assert_eq!(label.package.unwrap(), "package");
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn root_label() {
+        let label = Label::from_str("@repo//:target").unwrap();
+        assert_eq!(label.repository.unwrap(), "repo");
+        assert_eq!(label.package, None);
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn root_label_no_repository() {
+        let label = Label::from_str("//:target").unwrap();
+        assert_eq!(label.repository, None);
+        assert_eq!(label.package, None);
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn root_label_no_slashes() {
+        let label = Label::from_str(":target").unwrap();
+        assert_eq!(label.repository, None);
+        assert_eq!(label.package, None);
+        assert_eq!(label.target, "target");
+    }
+
+    #[test]
+    fn full_label_with_slash_after_colon() {
+        let label = Label::from_str("@repo//package/sub_package:subdir/target").unwrap();
+        assert_eq!(label.repository.unwrap(), "repo");
+        assert_eq!(label.package.unwrap(), "package/sub_package");
+        assert_eq!(label.target, "subdir/target");
+    }
+
+    #[test]
+    fn invalid_double_colon() {
+        assert!(Label::from_str("::target").is_err());
+    }
+
+    #[test]
+    fn invalid_double_at() {
+        assert!(Label::from_str("@@repo//pkg:target").is_err());
+    }
+
+    #[test]
+    #[ignore = "This currently fails. The Label parsing logic needs to be updated"]
+    fn invalid_no_double_slash() {
+        assert!(Label::from_str("@repo:target").is_err());
+    }
+
+    #[test]
+    fn from_absolute_path_exists() {
+        let dir = tempdir().unwrap();
+        let workspace = dir.path().join("WORKSPACE.bazel");
+        let build_file = dir.path().join("parent").join("child").join("BUILD.bazel");
+        let subdir = dir.path().join("parent").join("child").join("grandchild");
+        let actual_file = subdir.join("greatgrandchild");
+        create_dir_all(subdir).unwrap();
+        {
+            File::create(&workspace).unwrap();
+            File::create(&build_file).unwrap();
+            File::create(&actual_file).unwrap();
+        }
+        let label = Label::from_absolute_path(&actual_file).unwrap();
+        assert_eq!(label.repository, None);
+        assert_eq!(label.package.unwrap(), "parent/child");
+        assert_eq!(label.target, "grandchild/greatgrandchild")
+    }
+
+    #[test]
+    fn from_absolute_path_no_workspace() {
+        let dir = tempdir().unwrap();
+        let build_file = dir.path().join("parent").join("child").join("BUILD.bazel");
+        let subdir = dir.path().join("parent").join("child").join("grandchild");
+        let actual_file = subdir.join("greatgrandchild");
+        create_dir_all(subdir).unwrap();
+        {
+            File::create(&build_file).unwrap();
+            File::create(&actual_file).unwrap();
+        }
+        let err = Label::from_absolute_path(&actual_file)
+            .unwrap_err()
+            .to_string();
+        assert_that(&err).contains("Could not identify workspace");
+        assert_that(&err).contains(format!("{}", actual_file.display()).as_str());
+    }
+
+    #[test]
+    fn from_absolute_path_no_build_file() {
+        let dir = tempdir().unwrap();
+        let workspace = dir.path().join("WORKSPACE.bazel");
+        let subdir = dir.path().join("parent").join("child").join("grandchild");
+        let actual_file = subdir.join("greatgrandchild");
+        create_dir_all(subdir).unwrap();
+        {
+            File::create(&workspace).unwrap();
+            File::create(&actual_file).unwrap();
+        }
+        let err = Label::from_absolute_path(&actual_file)
+            .unwrap_err()
+            .to_string();
+        assert_that(&err).contains("Could not identify package");
+        assert_that(&err).contains("Maybe you need to add a BUILD.bazel file");
+        assert_that(&err).contains(format!("{}", actual_file.display()).as_str());
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/src/utils/starlark/select.rs b/third_party/rules_rust/crate_universe/src/utils/starlark/select.rs
new file mode 100644
index 0000000..4a8a3cc
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/src/utils/starlark/select.rs
@@ -0,0 +1,166 @@
+use serde::{Deserialize, Serialize};
+use std::collections::{btree_set, BTreeMap, BTreeSet};
+use std::iter::once;
+
+pub trait SelectMap<T, U> {
+    // A selectable should also implement a `map` function allowing one type of selectable
+    // to be mutated into another. However, the approach I'm looking for requires GAT
+    // (Generic Associated Types) which are not yet stable.
+    // https://github.com/rust-lang/rust/issues/44265
+    type Mapped;
+    fn map<F: Copy + Fn(T) -> U>(self, func: F) -> Self::Mapped;
+}
+
+pub trait Select<T> {
+    /// Gather a list of all conditions currently set on the selectable. A conditional
+    /// would be the key of the select statement.
+    fn configurations(&self) -> BTreeSet<Option<&String>>;
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, Clone)]
+pub struct SelectList<T: Ord> {
+    common: BTreeSet<T>,
+    selects: BTreeMap<String, BTreeSet<T>>,
+}
+
+impl<T: Ord> Default for SelectList<T> {
+    fn default() -> Self {
+        Self {
+            common: BTreeSet::new(),
+            selects: BTreeMap::new(),
+        }
+    }
+}
+
+impl<T: Ord> SelectList<T> {
+    // TODO: This should probably be added to the [Select] trait
+    pub fn insert(&mut self, value: T, configuration: Option<String>) {
+        match configuration {
+            None => {
+                self.common.insert(value);
+            }
+            Some(cfg) => {
+                match self.selects.get_mut(&cfg) {
+                    None => {
+                        let mut set = BTreeSet::new();
+                        set.insert(value);
+                        self.selects.insert(cfg, set);
+                    }
+                    Some(set) => {
+                        set.insert(value);
+                    }
+                };
+            }
+        };
+    }
+
+    // TODO: This should probably be added to the [Select] trait
+    pub fn get_iter<'a>(&'a self, config: Option<&String>) -> Option<btree_set::Iter<T>> {
+        match config {
+            Some(conf) => self.selects.get(conf).map(|set| set.iter()),
+            None => Some(self.common.iter()),
+        }
+    }
+
+    /// Determine whether or not the select should be serialized
+    pub fn should_skip_serializing(&self) -> bool {
+        self.common.is_empty() && self.selects.is_empty()
+    }
+}
+
+impl<T: Ord> Select<T> for SelectList<T> {
+    fn configurations(&self) -> BTreeSet<Option<&String>> {
+        let configs = self.selects.keys().map(Some);
+        match self.common.is_empty() {
+            true => configs.collect(),
+            false => configs.chain(once(None)).collect(),
+        }
+    }
+}
+
+impl<T: Ord, U: Ord> SelectMap<T, U> for SelectList<T> {
+    type Mapped = SelectList<U>;
+
+    fn map<F: Copy + Fn(T) -> U>(self, func: F) -> Self::Mapped {
+        SelectList {
+            common: self.common.into_iter().map(func).collect(),
+            selects: self
+                .selects
+                .into_iter()
+                .map(|(key, map)| (key, map.into_iter().map(func).collect()))
+                .collect(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, Clone)]
+pub struct SelectDict<T: Ord> {
+    common: BTreeMap<String, T>,
+    selects: BTreeMap<String, BTreeMap<String, T>>,
+}
+
+impl<T: Ord> Default for SelectDict<T> {
+    fn default() -> Self {
+        Self {
+            common: BTreeMap::new(),
+            selects: BTreeMap::new(),
+        }
+    }
+}
+
+impl<T: Ord> SelectDict<T> {
+    // TODO: This should probably be added to the [Select] trait
+    pub fn insert(&mut self, value: BTreeMap<String, T>, configuration: Option<String>) {
+        match configuration {
+            None => {
+                self.common.extend(value);
+            }
+            Some(cfg) => {
+                match self.selects.get_mut(&cfg) {
+                    None => {
+                        let mut set = BTreeMap::new();
+                        set.extend(value);
+                        self.selects.insert(cfg, set);
+                    }
+                    Some(set) => {
+                        set.extend(value);
+                    }
+                };
+            }
+        };
+    }
+
+    /// Determine whether or not the select should be serialized
+    pub fn should_skip_serializing(&self) -> bool {
+        self.common.is_empty() && self.selects.is_empty()
+    }
+}
+
+impl<T: Ord> Select<T> for SelectDict<T> {
+    fn configurations(&self) -> BTreeSet<Option<&String>> {
+        let configs = self.selects.keys().map(Some);
+        match self.common.is_empty() {
+            true => configs.collect(),
+            false => configs.chain(once(None)).collect(),
+        }
+    }
+}
+
+impl<T: Ord, U: Ord> SelectMap<T, U> for SelectDict<T> {
+    type Mapped = SelectDict<U>;
+
+    fn map<F: Copy + Fn(T) -> U>(self, func: F) -> Self::Mapped {
+        SelectDict {
+            common: self
+                .common
+                .into_iter()
+                .map(|(key, val)| (key, func(val)))
+                .collect(),
+            selects: self
+                .selects
+                .into_iter()
+                .map(|(key, map)| (key, map.into_iter().map(|(k, v)| (k, func(v))).collect()))
+                .collect(),
+        }
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.lock
new file mode 100644
index 0000000..fd659b2
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.lock
@@ -0,0 +1,358 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aliases"
+version = "0.1.0"
+dependencies = [
+ "log 0.3.9",
+ "log 0.4.14",
+ "names 0.12.1-dev",
+ "names 0.13.0",
+ "value-bag",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "3.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312"
+dependencies = [
+ "atty",
+ "bitflags",
+ "clap_derive",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "strsim",
+ "termcolor",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+dependencies = [
+ "log 0.4.14",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "names"
+version = "0.12.1-dev"
+source = "git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f"
+dependencies = [
+ "clap",
+ "rand",
+]
+
+[[package]]
+name = "names"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7d66043b25d4a6cccb23619d10c19c25304b355a7dccd4a8e11423dd2382146"
+dependencies = [
+ "clap",
+ "rand",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "value-bag"
+version = "1.0.0-alpha.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd320e1520f94261153e96f7534476ad869c14022aee1e59af7c778075d840ae"
+dependencies = [
+ "ctor",
+ "version_check",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.toml
new file mode 100644
index 0000000..816a328
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/Cargo.toml
@@ -0,0 +1,25 @@
+[workspace]
+
+[package]
+name = "aliases"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Defines library targets
+log = "=0.4.14"
+pinned_log = { package = "log", version = "=0.3.9" }
+
+# Contains a transitive alias
+value-bag = "=1.0.0-alpha.7"
+
+# Defines binary targets
+names = "=0.13.0"
+pinned_names = { package = "names", git = "https://github.com/fnichol/names.git", rev = "760516503b89ddc8bc2ab42d579d4566cfb1054f" }
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/aliases/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/metadata.json
new file mode 100644
index 0000000..7ae3bb0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/aliases/metadata.json
@@ -0,0 +1,8781 @@
+{
+    "packages": [
+        {
+            "name": "aliases",
+            "version": "0.1.0",
+            "id": "aliases 0.1.0 (path+file://{TEMP_DIR}/aliases)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.4.14",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "names",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.13.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.3.9",
+                    "kind": null,
+                    "rename": "pinned_log",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "names",
+                    "source": "git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f",
+                    "req": "*",
+                    "kind": null,
+                    "rename": "pinned_names",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "value-bag",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.0.0-alpha.7",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "aliases",
+                    "src_path": "{TEMP_DIR}/aliases/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/aliases/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "atty",
+            "version": "0.2.14",
+            "id": "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "A simple interface for querying atty",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "hermit-abi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.6",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(target_os = \"hermit\")",
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": "cfg(unix)",
+                    "registry": null
+                },
+                {
+                    "name": "winapi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "consoleapi",
+                        "processenv",
+                        "minwinbase",
+                        "minwindef",
+                        "winbase"
+                    ],
+                    "target": "cfg(windows)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "atty",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/atty-0.2.14/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "atty",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/atty-0.2.14/examples/atty.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/atty-0.2.14/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "softprops <d.tangren@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "terminal",
+                "tty",
+                "isatty"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/softprops/atty",
+            "homepage": "https://github.com/softprops/atty",
+            "documentation": "http://softprops.github.io/atty",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "autocfg",
+            "version": "1.1.0",
+            "id": "autocfg 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "Automatic cfg for Rust compiler features",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "autocfg",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "integers",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/examples/integers.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "paths",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/examples/paths.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "versions",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/examples/versions.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "traits",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/examples/traits.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rustflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/tests/rustflags.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.1.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::build-utils"
+            ],
+            "keywords": [
+                "rustc",
+                "build",
+                "autoconf"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/cuviper/autocfg",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "bitflags",
+            "version": "1.3.2",
+            "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to generate structures which behave like bitflags.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "bitflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compile",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/compile.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "basic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/basic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "example_generated": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "example_generated"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "bit",
+                "bitmask",
+                "bitflags",
+                "flags"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/bitflags/bitflags",
+            "homepage": "https://github.com/bitflags/bitflags",
+            "documentation": "https://docs.rs/bitflags",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "cfg-if",
+            "version": "1.0.0",
+            "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to ergonomically define an item depending on a large number of #[cfg]\nparameters. Structured like an if-else chain, the first matching branch is the\nitem that gets emitted.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cfg-if",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xcrate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/tests/xcrate.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cfg-if",
+            "homepage": "https://github.com/alexcrichton/cfg-if",
+            "documentation": "https://docs.rs/cfg-if",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "clap",
+            "version": "3.1.5",
+            "id": "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "A simple to use, efficient, and full-featured Command Line Argument Parser",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "atty",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "backtrace",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "bitflags",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "clap_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.1.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "indexmap",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "os_str_bytes",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^6.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "strsim",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.10",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "termcolor",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.1.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "terminal_size",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.12",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "textwrap",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.15.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unicase",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.6",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "yaml-rust",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "criterion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.18",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trycmd",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.12",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [
+                        "color-auto",
+                        "diff",
+                        "examples"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "clap",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "demo",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/demo.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cargo-example",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/cargo-example.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cargo-example-derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/cargo-example-derive.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "escaped-positional",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/escaped-positional.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "escaped-positional-derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/escaped-positional-derive.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "git-derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/git-derive.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "keyvalue-derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/keyvalue-derive.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "busybox",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/multicall-busybox.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "unstable-multicall"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "hostname",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/multicall-hostname.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "unstable-multicall"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "01_quick",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/01_quick.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_apps",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/02_apps.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_crate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/02_crate.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_app_settings",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/02_app_settings.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_01_flag_bool",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_01_flag_bool.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_01_flag_count",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_01_flag_count.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_02_option",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_02_option.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_03_positional",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_03_positional.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_04_subcommands",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_04_subcommands.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_05_default_values",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/03_05_default_values.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_01_possible",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_01_possible.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_01_enum",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_01_enum.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo",
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_02_parse",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_02_parse.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_02_validate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_02_validate.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_03_relations",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_03_relations.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_04_custom",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/04_04_custom.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "05_01_assert",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_builder/05_01_assert.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "cargo"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "01_quick_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/01_quick.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_apps_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/02_apps.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_crate_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/02_crate.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_app_settings_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/02_app_settings.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_01_flag_bool_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_01_flag_bool.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_01_flag_count_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_01_flag_count.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_02_option_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_02_option.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_03_positional_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_03_positional.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_04_subcommands_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_04_subcommands.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_04_subcommands_alt_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_04_subcommands_alt.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_05_default_values_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/03_05_default_values.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_01_enum_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/04_01_enum.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_02_parse_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/04_02_parse.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_02_validate_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/04_02_validate.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_03_relations_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/04_03_relations.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_04_custom_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/04_04_custom.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "05_01_assert_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/tutorial_derive/05_01_assert.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "custom-bool",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/derive_ref/custom-bool.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "derive"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "pacman",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/pacman.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "git",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/examples/git.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "01_default",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/01_default.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "02_simple",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/02_simple.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "03_complex",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/03_complex.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "04_new_help",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/04_new_help.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "05_ripgrep",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/05_ripgrep.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "06_rustup",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/benches/06_rustup.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "cargo": [
+                    "lazy_static"
+                ],
+                "color": [
+                    "atty",
+                    "termcolor"
+                ],
+                "debug": [
+                    "clap_derive/debug",
+                    "backtrace"
+                ],
+                "default": [
+                    "std",
+                    "color",
+                    "suggestions"
+                ],
+                "derive": [
+                    "clap_derive",
+                    "lazy_static"
+                ],
+                "env": [],
+                "std": [
+                    "indexmap/std"
+                ],
+                "suggestions": [
+                    "strsim"
+                ],
+                "unicode": [
+                    "textwrap/unicode-width",
+                    "unicase"
+                ],
+                "unstable-doc": [
+                    "derive",
+                    "cargo",
+                    "wrap_help",
+                    "yaml",
+                    "env",
+                    "unicode",
+                    "regex",
+                    "unstable-replace",
+                    "unstable-multicall",
+                    "unstable-grouped"
+                ],
+                "unstable-grouped": [],
+                "unstable-multicall": [],
+                "unstable-replace": [],
+                "unstable-v4": [],
+                "wrap_help": [
+                    "terminal_size",
+                    "textwrap/terminal_size"
+                ],
+                "yaml": [
+                    "yaml-rust"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap-3.1.5/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "cargo-args": [
+                            "-Zunstable-options",
+                            "-Zrustdoc-scrape-examples=examples"
+                        ],
+                        "features": [
+                            "unstable-doc"
+                        ],
+                        "rustdoc-args": [
+                            "--cfg",
+                            "docsrs"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "unstable-doc"
+                    ]
+                },
+                "release": {
+                    "shared-version": true,
+                    "tag-name": "v{{version}}",
+                    "pre-release-replacements": [
+                        {
+                            "file": "CHANGELOG.md",
+                            "min": 1,
+                            "replace": "{{version}}",
+                            "search": "Unreleased"
+                        },
+                        {
+                            "exactly": 1,
+                            "file": "CHANGELOG.md",
+                            "replace": "...{{tag_name}}",
+                            "search": "\\.\\.\\.HEAD"
+                        },
+                        {
+                            "file": "CHANGELOG.md",
+                            "min": 1,
+                            "replace": "{{date}}",
+                            "search": "ReleaseDate"
+                        },
+                        {
+                            "exactly": 1,
+                            "file": "CHANGELOG.md",
+                            "replace": "<!-- next-header -->\n## [Unreleased] - ReleaseDate\n",
+                            "search": "<!-- next-header -->"
+                        },
+                        {
+                            "exactly": 1,
+                            "file": "CHANGELOG.md",
+                            "replace": "<!-- next-url -->\n[Unreleased]: https://github.com/clap-rs/clap/compare/{{tag_name}}...HEAD",
+                            "search": "<!-- next-url -->"
+                        },
+                        {
+                            "exactly": 13,
+                            "file": "README.md",
+                            "prerelease": true,
+                            "replace": "github.com/clap-rs/clap/blob/{{tag_name}}/",
+                            "search": "github.com/clap-rs/clap/blob/[^/]+/"
+                        },
+                        {
+                            "exactly": 1,
+                            "file": "README.md",
+                            "prerelease": true,
+                            "replace": "version = \"{{version}}\"",
+                            "search": "version = \"[a-z0-9\\.-]+\""
+                        },
+                        {
+                            "exactly": 4,
+                            "file": "src/derive.rs",
+                            "prerelease": true,
+                            "replace": "github.com/clap-rs/clap/blob/{{tag_name}}/",
+                            "search": "github.com/clap-rs/clap/blob/[^/]+/"
+                        }
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "command-line-interface"
+            ],
+            "keywords": [
+                "argument",
+                "cli",
+                "arg",
+                "parser",
+                "parse"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/clap-rs/clap",
+            "homepage": null,
+            "documentation": "https://docs.rs/clap/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "clap_derive",
+            "version": "3.1.4",
+            "id": "clap_derive 3.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Parse command line argument by defining a struct, derive crate.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "heck",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "proc-macro-error",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.28",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.74",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "full"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "proc-macro"
+                    ],
+                    "crate_types": [
+                        "proc-macro"
+                    ],
+                    "name": "clap_derive",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap_derive-3.1.4/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "debug": [],
+                "default": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/clap_derive-3.1.4/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                },
+                "release": {
+                    "dependent-version": "upgrade",
+                    "shared-version": true,
+                    "tag-name": "v{{version}}",
+                    "pre-release-replacements": [
+                        {
+                            "exactly": 2,
+                            "file": "README.md",
+                            "prerelease": true,
+                            "replace": "github.com/clap-rs/clap/blob/{{tag_name}}/",
+                            "search": "github.com/clap-rs/clap/blob/[^/]+/"
+                        }
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "command-line-interface",
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "clap",
+                "cli",
+                "parse",
+                "derive",
+                "proc_macro"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/clap-rs/clap/tree/master/clap_derive",
+            "homepage": null,
+            "documentation": "https://docs.rs/clap_derive",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "ctor",
+            "version": "0.1.21",
+            "id": "ctor 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "__attribute__((constructor)) for Rust",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.73",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [
+                        "full",
+                        "parsing",
+                        "printing",
+                        "proc-macro"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc-print",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.15",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "proc-macro"
+                    ],
+                    "crate_types": [
+                        "proc-macro"
+                    ],
+                    "name": "ctor",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ctor-0.1.21/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "example",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ctor-0.1.21/src/example.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ctor-0.1.21/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Matt Mastracci <matthew@mastracci.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "../README.md",
+            "repository": "https://github.com/mmastrac/rust-ctor",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "getrandom",
+            "version": "0.2.5",
+            "id": "getrandom 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "A small cross-platform library for retrieving random data from system source",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "js-sys",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))",
+                    "registry": null
+                },
+                {
+                    "name": "wasm-bindgen",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.62",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": "cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))",
+                    "registry": null
+                },
+                {
+                    "name": "wasm-bindgen-test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.18",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))",
+                    "registry": null
+                },
+                {
+                    "name": "wasi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.10",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(target_os = \"wasi\")",
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.64",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": "cfg(unix)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "getrandom",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "normal",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/tests/normal.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "custom",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/tests/custom.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rdrand",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/tests/rdrand.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "mod",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/benches/mod.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "custom": [],
+                "js": [
+                    "wasm-bindgen",
+                    "js-sys"
+                ],
+                "rdrand": [],
+                "rustc-dep-of-std": [
+                    "compiler_builtins",
+                    "core",
+                    "libc/rustc-dep-of-std",
+                    "wasi/rustc-dep-of-std"
+                ],
+                "std": [],
+                "test-in-browser": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/getrandom-0.2.5/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "std",
+                            "custom"
+                        ],
+                        "rustdoc-args": [
+                            "--cfg",
+                            "docsrs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rand Project Developers"
+            ],
+            "categories": [
+                "os",
+                "no-std"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-random/getrandom",
+            "homepage": null,
+            "documentation": "https://docs.rs/getrandom",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "hashbrown",
+            "version": "0.11.2",
+            "id": "hashbrown 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0/MIT",
+            "license_file": null,
+            "description": "A Rust port of Google's SwissTable hash map",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "ahash",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.7.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-alloc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "alloc",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "bumpalo",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.5.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.25",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "doc-comment",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "fnv",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.7",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.4",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.7.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "small_rng"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "hashbrown",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "serde",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/tests/serde.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rayon",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/tests/rayon.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "set",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/tests/set.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "hasher",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/tests/hasher.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/benches/bench.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "ahash-compile-time-rng": [
+                    "ahash/compile-time-rng"
+                ],
+                "default": [
+                    "ahash",
+                    "inline-more"
+                ],
+                "inline-more": [],
+                "nightly": [],
+                "raw": [],
+                "rustc-dep-of-std": [
+                    "nightly",
+                    "core",
+                    "compiler_builtins",
+                    "alloc",
+                    "rustc-internal-api"
+                ],
+                "rustc-internal-api": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.11.2/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "nightly",
+                            "rayon",
+                            "serde",
+                            "raw"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Amanieu d'Antras <amanieu@gmail.com>"
+            ],
+            "categories": [
+                "data-structures",
+                "no-std"
+            ],
+            "keywords": [
+                "hash",
+                "no_std",
+                "hashmap",
+                "swisstable"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/hashbrown",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "heck",
+            "version": "0.4.0",
+            "id": "heck 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "heck is a case conversion library.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "unicode-segmentation",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "heck",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/heck-0.4.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "unicode": [
+                    "unicode-segmentation"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/heck-0.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Without Boats <woboats@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "string",
+                "case",
+                "camel",
+                "snake",
+                "unicode"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/withoutboats/heck",
+            "homepage": "https://github.com/withoutboats/heck",
+            "documentation": "https://docs.rs/heck",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "hermit-abi",
+            "version": "0.1.19",
+            "id": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "hermit-abi is small interface to call functions from the unikernel RustyHermit.\nIt is used to build the target `x86_64-unknown-hermit`.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.51",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "hermit-abi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hermit-abi-0.1.19/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "docs": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins/rustc-dep-of-std",
+                    "libc/rustc-dep-of-std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hermit-abi-0.1.19/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-unknown-hermit",
+                        "features": [
+                            "docs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Stefan Lankes"
+            ],
+            "categories": [
+                "os"
+            ],
+            "keywords": [
+                "unikernel",
+                "libos"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/hermitcore/libhermit-rs",
+            "homepage": null,
+            "documentation": "https://hermitcore.github.io/rusty-hermit/hermit_abi",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "indexmap",
+            "version": "1.8.0",
+            "id": "indexmap 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0/MIT",
+            "license_file": null,
+            "description": "A hash table with consistent order and fast iteration.\n\nThe indexmap is a hash table where the iteration order of the key-value\npairs is independent of the hash values of the keys. It has the usual\nhash table functionality, it preserves insertion order except after\nremovals, and it allows lookup of its elements by either hash table key\nor numerical index. A corresponding hash set type is also provided.\n\nThis crate was initially published under the name ordermap, but it was renamed to\nindexmap.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "hashbrown",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.11",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [
+                        "raw"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.4.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "fnv",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "fxhash",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "itertools",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quickcheck",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.7",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "small_rng"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "autocfg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "indexmap",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "quick",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/tests/quick.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macros_full_path",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/tests/macros_full_path.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "equivalent_trait",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/tests/equivalent_trait.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "tests",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/tests/tests.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "faststring",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/benches/faststring.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/benches/bench.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "serde-1": [
+                    "serde"
+                ],
+                "std": [],
+                "test_debug": [],
+                "test_low_transition_point": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/indexmap-1.8.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "serde-1",
+                            "rayon"
+                        ]
+                    }
+                },
+                "release": {
+                    "no-dev-version": true,
+                    "tag-name": "{{version}}"
+                }
+            },
+            "publish": null,
+            "authors": [
+                "bluss",
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "data-structures",
+                "no-std"
+            ],
+            "keywords": [
+                "hashmap",
+                "no_std"
+            ],
+            "readme": null,
+            "repository": "https://github.com/bluss/indexmap",
+            "homepage": null,
+            "documentation": "https://docs.rs/indexmap/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "lazy_static",
+            "version": "1.4.0",
+            "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro for declaring lazily evaluated statics in Rust.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "spin",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "doc-comment",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/test.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "no_std",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/no_std.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "spin_no_std": [
+                    "spin"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Marvin L\u00f6bel <loebel.marvin@gmail.com>"
+            ],
+            "categories": [
+                "no-std",
+                "rust-patterns",
+                "memory-management"
+            ],
+            "keywords": [
+                "macro",
+                "lazy",
+                "static"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang-nursery/lazy-static.rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/lazy_static",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "libc",
+            "version": "0.2.119",
+            "id": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings to platform libraries like libc.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "libc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.119/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "const_fn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.119/tests/const_fn.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.119/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "align": [],
+                "const-extern-fn": [],
+                "default": [
+                    "std"
+                ],
+                "extra_traits": [],
+                "rustc-dep-of-std": [
+                    "align",
+                    "rustc-std-workspace-core"
+                ],
+                "std": [],
+                "use_std": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.119/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "const-extern-fn",
+                            "extra_traits"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os"
+            ],
+            "keywords": [
+                "libc",
+                "ffi",
+                "bindings",
+                "operating",
+                "system"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/libc",
+            "homepage": "https://github.com/rust-lang/libc",
+            "documentation": "https://docs.rs/libc/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "log",
+            "version": "0.3.9",
+            "id": "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A lightweight logging facade for Rust\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "log",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.3.9/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "use_std"
+                ],
+                "max_level_debug": [
+                    "log/max_level_debug"
+                ],
+                "max_level_error": [
+                    "log/max_level_error"
+                ],
+                "max_level_info": [
+                    "log/max_level_info"
+                ],
+                "max_level_off": [
+                    "log/max_level_off"
+                ],
+                "max_level_trace": [
+                    "log/max_level_trace"
+                ],
+                "max_level_warn": [
+                    "log/max_level_warn"
+                ],
+                "nightly": [],
+                "release_max_level_debug": [
+                    "log/release_max_level_debug"
+                ],
+                "release_max_level_error": [
+                    "log/release_max_level_error"
+                ],
+                "release_max_level_info": [
+                    "log/release_max_level_info"
+                ],
+                "release_max_level_off": [
+                    "log/release_max_level_off"
+                ],
+                "release_max_level_trace": [
+                    "log/release_max_level_trace"
+                ],
+                "release_max_level_warn": [
+                    "log/release_max_level_warn"
+                ],
+                "use_std": [
+                    "log/std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.3.9/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "development-tools::debugging"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/log",
+            "homepage": "https://github.com/rust-lang/log",
+            "documentation": "https://doc.rust-lang.org/log",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "log",
+            "version": "0.4.14",
+            "id": "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "A lightweight logging facade for Rust\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sval",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "value-bag",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.6",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sval",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.5",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "value-bag",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.6",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "test"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "log",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "filters",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/tests/filters.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macros",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/tests/macros.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "value",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/benches/value.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "kv_unstable": [
+                    "value-bag"
+                ],
+                "kv_unstable_serde": [
+                    "kv_unstable_std",
+                    "value-bag/serde",
+                    "serde"
+                ],
+                "kv_unstable_std": [
+                    "std",
+                    "kv_unstable",
+                    "value-bag/error"
+                ],
+                "kv_unstable_sval": [
+                    "kv_unstable",
+                    "value-bag/sval",
+                    "sval"
+                ],
+                "max_level_debug": [],
+                "max_level_error": [],
+                "max_level_info": [],
+                "max_level_off": [],
+                "max_level_trace": [],
+                "max_level_warn": [],
+                "release_max_level_debug": [],
+                "release_max_level_error": [],
+                "release_max_level_info": [],
+                "release_max_level_off": [],
+                "release_max_level_trace": [],
+                "release_max_level_warn": [],
+                "std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/log-0.4.14/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "std",
+                            "serde",
+                            "kv_unstable_std",
+                            "kv_unstable_sval",
+                            "kv_unstable_serde"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "development-tools::debugging"
+            ],
+            "keywords": [
+                "logging"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/log",
+            "homepage": null,
+            "documentation": "https://docs.rs/log",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "memchr",
+            "version": "2.4.1",
+            "id": "memchr 2.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Unlicense/MIT",
+            "license_file": null,
+            "description": "Safe interface to memchr.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.18",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quickcheck",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "memchr",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memchr-2.4.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memchr-2.4.1/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ],
+                "std": [],
+                "use_std": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memchr-2.4.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Andrew Gallant <jamslam@gmail.com>",
+                "bluss"
+            ],
+            "categories": [],
+            "keywords": [
+                "memchr",
+                "char",
+                "scan",
+                "strchr",
+                "string"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/BurntSushi/memchr",
+            "homepage": "https://github.com/BurntSushi/memchr",
+            "documentation": "https://docs.rs/memchr/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "names",
+            "version": "0.12.1-dev",
+            "id": "names 0.12.1-dev (git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "A random name generator with names suitable for use in container\ninstances, project names, application instances, etc.\n",
+            "source": "git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f",
+            "dependencies": [
+                {
+                    "name": "clap",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.1.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version-sync",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "names",
+                    "src_path": "{CARGO_HOME}/git/checkouts/names-1a8772e9ce82304c/7605165/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bin"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "names",
+                    "src_path": "{CARGO_HOME}/git/checkouts/names-1a8772e9ce82304c/7605165/src/bin/names.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "version-numbers",
+                    "src_path": "{CARGO_HOME}/git/checkouts/names-1a8772e9ce82304c/7605165/tests/version-numbers.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/git/checkouts/names-1a8772e9ce82304c/7605165/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "application": [
+                    "clap"
+                ],
+                "default": [
+                    "application"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/git/checkouts/names-1a8772e9ce82304c/7605165/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "no-default-features": true
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Fletcher Nichol <fnichol@nichol.ca>"
+            ],
+            "categories": [
+                "command-line-utilities"
+            ],
+            "keywords": [
+                "name",
+                "random"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/fnichol/names",
+            "homepage": "https://github.com/fnichol/names",
+            "documentation": "https://docs.rs/names",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "names",
+            "version": "0.13.0",
+            "id": "names 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "A random name generator with names suitable for use in container\ninstances, project names, application instances, etc.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "clap",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.1.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version-sync",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "names",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/names-0.13.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bin"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "names",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/names-0.13.0/src/bin/names.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "version-numbers",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/names-0.13.0/tests/version-numbers.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/names-0.13.0/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "application": [
+                    "clap"
+                ],
+                "default": [
+                    "application"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/names-0.13.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "no-default-features": true
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Fletcher Nichol <fnichol@nichol.ca>"
+            ],
+            "categories": [
+                "command-line-utilities"
+            ],
+            "keywords": [
+                "name",
+                "random"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/fnichol/names",
+            "homepage": "https://github.com/fnichol/names",
+            "documentation": "https://docs.rs/names",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "os_str_bytes",
+            "version": "6.0.0",
+            "id": "os_str_bytes 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Utilities for converting between byte sequences and platform-native strings\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "memchr",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "print_bytes",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "uniquote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "getrandom",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "os_str_bytes",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/os_str_bytes-6.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "memchr",
+                    "raw_os_str"
+                ],
+                "raw_os_str": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/os_str_bytes-6.0.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustc-args": [
+                            "--cfg",
+                            "os_str_bytes_docs_rs"
+                        ],
+                        "rustdoc-args": [
+                            "--cfg",
+                            "os_str_bytes_docs_rs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "dylni"
+            ],
+            "categories": [
+                "command-line-interface",
+                "development-tools::ffi",
+                "encoding",
+                "os",
+                "rust-patterns"
+            ],
+            "keywords": [
+                "bytes",
+                "osstr",
+                "osstring",
+                "path",
+                "windows"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dylni/os_str_bytes",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.52.0"
+        },
+        {
+            "name": "ppv-lite86",
+            "version": "0.2.16",
+            "id": "ppv-lite86 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Implementation of the crypto-simd API for x86",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "ppv-lite86",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ppv-lite86-0.2.16/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "no_simd": [],
+                "simd": [],
+                "std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ppv-lite86-0.2.16/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "The CryptoCorrosion Contributors"
+            ],
+            "categories": [
+                "cryptography",
+                "no-std"
+            ],
+            "keywords": [
+                "crypto",
+                "simd",
+                "x86"
+            ],
+            "readme": null,
+            "repository": "https://github.com/cryptocorrosion/cryptocorrosion",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "proc-macro-error",
+            "version": "1.0.4",
+            "id": "proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Almost drop-in replacement to panics in proc-macros",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro-error-attr",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.0.107",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "toml",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.5.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.19",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "diff"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version_check",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "proc-macro-error",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "ok",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/tests/ok.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macro-errors",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/tests/macro-errors.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "runtime-errors",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/tests/runtime-errors.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "syn-error"
+                ],
+                "syn-error": [
+                    "syn"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-1.0.4/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "CreepySkeleton <creepy-skeleton@yandex.ru>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "proc-macro",
+                "error",
+                "errors"
+            ],
+            "readme": "README.md",
+            "repository": "https://gitlab.com/CreepySkeleton/proc-macro-error",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "proc-macro-error-attr",
+            "version": "1.0.4",
+            "id": "proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Attribute macro for proc-macro-error crate",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version_check",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "proc-macro"
+                    ],
+                    "crate_types": [
+                        "proc-macro"
+                    ],
+                    "name": "proc-macro-error-attr",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-attr-1.0.4/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-attr-1.0.4/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro-error-attr-1.0.4/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "CreepySkeleton <creepy-skeleton@yandex.ru>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": "https://gitlab.com/CreepySkeleton/proc-macro-error",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "proc-macro2",
+            "version": "1.0.36",
+            "id": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "A substitute implementation of the compiler's `proc_macro` API to decouple\ntoken-based libraries from the procedural macro use case.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "unicode-xid",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "proc-macro2",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "features",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/features.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_fmt",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/test_fmt.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "comments",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/comments.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "marker",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/marker.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "proc-macro"
+                ],
+                "nightly": [],
+                "proc-macro": [],
+                "span-locations": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "rustc-args": [
+                            "--cfg",
+                            "procmacro2_semver_exempt"
+                        ],
+                        "rustdoc-args": [
+                            "--cfg",
+                            "procmacro2_semver_exempt",
+                            "--cfg",
+                            "doc_cfg"
+                        ],
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "span-locations"
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>",
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "macros"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/proc-macro2",
+            "homepage": null,
+            "documentation": "https://docs.rs/proc-macro2",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "quote",
+            "version": "1.0.15",
+            "id": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Quasi-quoting macro quote!(...)",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.36",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.52",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "diff"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "quote",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.15/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.15/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compiletest",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.15/tests/compiletest.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "proc-macro"
+                ],
+                "proc-macro": [
+                    "proc-macro2/proc-macro"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.15/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "syn"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/quote",
+            "homepage": null,
+            "documentation": "https://docs.rs/quote/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "rand",
+            "version": "0.8.5",
+            "id": "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Random number generators and other randomness functionality.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "packed_simd_2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.7",
+                    "kind": null,
+                    "rename": "packed_simd",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "into_bits"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_chacha",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.6.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.103",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "bincode",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_pcg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.22",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": "cfg(unix)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "rand",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand-0.8.5/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "alloc": [
+                    "rand_core/alloc"
+                ],
+                "default": [
+                    "std",
+                    "std_rng"
+                ],
+                "getrandom": [
+                    "rand_core/getrandom"
+                ],
+                "min_const_gen": [],
+                "nightly": [],
+                "serde1": [
+                    "serde",
+                    "rand_core/serde1"
+                ],
+                "simd_support": [
+                    "packed_simd"
+                ],
+                "small_rng": [],
+                "std": [
+                    "rand_core/std",
+                    "rand_chacha/std",
+                    "alloc",
+                    "getrandom",
+                    "libc"
+                ],
+                "std_rng": [
+                    "rand_chacha"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand-0.8.5/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "doc_cfg"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "small_rng",
+                        "serde1"
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rand Project Developers",
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "algorithms",
+                "no-std"
+            ],
+            "keywords": [
+                "random",
+                "rng"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-random/rand",
+            "homepage": "https://rust-random.github.io/book",
+            "documentation": "https://docs.rs/rand",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "rand_chacha",
+            "version": "0.3.1",
+            "id": "rand_chacha 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "ChaCha random number generator\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "ppv-lite86",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.8",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [
+                        "simd"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.6.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "rand_chacha",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand_chacha-0.3.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "serde1": [
+                    "serde"
+                ],
+                "simd": [],
+                "std": [
+                    "ppv-lite86/std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand_chacha-0.3.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "The Rand Project Developers",
+                "The Rust Project Developers",
+                "The CryptoCorrosion Contributors"
+            ],
+            "categories": [
+                "algorithms",
+                "no-std"
+            ],
+            "keywords": [
+                "random",
+                "rng",
+                "chacha"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-random/rand",
+            "homepage": "https://rust-random.github.io/book",
+            "documentation": "https://docs.rs/rand_chacha",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "rand_core",
+            "version": "0.6.3",
+            "id": "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Core random number generator traits and tools for implementation.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "getrandom",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "rand_core",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand_core-0.6.3/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "alloc": [],
+                "serde1": [
+                    "serde"
+                ],
+                "std": [
+                    "alloc",
+                    "getrandom",
+                    "getrandom/std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rand_core-0.6.3/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "doc_cfg"
+                        ]
+                    }
+                },
+                "playground": {
+                    "all-features": true
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rand Project Developers",
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "algorithms",
+                "no-std"
+            ],
+            "keywords": [
+                "random",
+                "rng"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-random/rand",
+            "homepage": "https://rust-random.github.io/book",
+            "documentation": "https://docs.rs/rand_core",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "strsim",
+            "version": "0.10.0",
+            "id": "strsim 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Implementations of string similarity metrics. Includes Hamming, Levenshtein,\nOSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and S\u00f8rensen-Dice.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "strsim",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/strsim-0.10.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "lib",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/strsim-0.10.0/tests/lib.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "benches",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/strsim-0.10.0/benches/benches.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/strsim-0.10.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Danny Guo <danny@dannyguo.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "string",
+                "similarity",
+                "Hamming",
+                "Levenshtein",
+                "Jaro"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dguo/strsim-rs",
+            "homepage": "https://github.com/dguo/strsim-rs",
+            "documentation": "https://docs.rs/strsim/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "syn",
+            "version": "1.0.86",
+            "id": "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Parser for Rust source code",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.32",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unicode-xid",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "anyhow",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "automod",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "flate2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "insta",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "ref-cast",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "reqwest",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.11",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "blocking"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn-test-suite",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tar",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.16",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "termcolor",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "syn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_should_parse",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_should_parse.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_visibility",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_visibility.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_stmt",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_stmt.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_round_trip",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_round_trip.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_size",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_size.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_shebang",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_shebang.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_pat",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_pat.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_receiver",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_receiver.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_precedence",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_precedence.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_lit",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_lit.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "regression",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/regression.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_parse_stream",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_parse_stream.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_grouping",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_grouping.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_ident",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_ident.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_iterators",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_iterators.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_parse_buffer",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_parse_buffer.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_asyncness",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_asyncness.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_token_trees",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_token_trees.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_ty",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_ty.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "zzz_stable",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/zzz_stable.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_meta",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_meta.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_expr",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_expr.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_item",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_item.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_path",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_path.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_derive_input",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_derive_input.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_generics",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_generics.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_attribute",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/tests/test_attribute.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rust",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/benches/rust.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "full",
+                        "parsing"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "file",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/benches/file.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "full",
+                        "parsing"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "clone-impls": [],
+                "default": [
+                    "derive",
+                    "parsing",
+                    "printing",
+                    "clone-impls",
+                    "proc-macro"
+                ],
+                "derive": [],
+                "extra-traits": [],
+                "fold": [],
+                "full": [],
+                "parsing": [],
+                "printing": [
+                    "quote"
+                ],
+                "proc-macro": [
+                    "proc-macro2/proc-macro",
+                    "quote/proc-macro"
+                ],
+                "test": [
+                    "syn-test-suite/all-features"
+                ],
+                "visit": [],
+                "visit-mut": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.86/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "doc_cfg"
+                        ],
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "full",
+                        "visit",
+                        "visit-mut",
+                        "fold",
+                        "extra-traits"
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/syn",
+            "homepage": null,
+            "documentation": "https://docs.rs/syn",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "termcolor",
+            "version": "1.1.3",
+            "id": "termcolor 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Unlicense OR MIT",
+            "license_file": null,
+            "description": "A simple cross platform library for writing colored text to a terminal.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "winapi-util",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(windows)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "termcolor",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/termcolor-1.1.3/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/termcolor-1.1.3/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Andrew Gallant <jamslam@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "windows",
+                "win",
+                "color",
+                "ansi",
+                "console"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/BurntSushi/termcolor",
+            "homepage": "https://github.com/BurntSushi/termcolor",
+            "documentation": "https://docs.rs/termcolor",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "textwrap",
+            "version": "0.15.0",
+            "id": "textwrap 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Powerful library for word wrapping, indenting, and dedenting strings",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "hyphenation",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "embed_en-us"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "smawk",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "terminal_size",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.17",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unicode-linebreak",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unicode-width",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "criterion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.5",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lipsum",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unic-emoji-char",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version-sync",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9.4",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "termion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.5.6",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(unix)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "textwrap",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "hyphenation",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/examples/hyphenation.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "hyphenation"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "termwidth",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/examples/termwidth.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "terminal_size"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "version-numbers",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/tests/version-numbers.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "indent",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/tests/indent.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "linear",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/benches/linear.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "indent",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/benches/indent.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "unicode-linebreak",
+                    "unicode-width",
+                    "smawk"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/textwrap-0.15.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Martin Geisler <martin@geisler.net>"
+            ],
+            "categories": [
+                "text-processing",
+                "command-line-interface"
+            ],
+            "keywords": [
+                "text",
+                "formatting",
+                "wrap",
+                "typesetting",
+                "hyphenation"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/mgeisler/textwrap",
+            "homepage": null,
+            "documentation": "https://docs.rs/textwrap/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "unicode-xid",
+            "version": "0.2.2",
+            "id": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Determine whether characters have the XID_Start\nor XID_Continue properties according to\nUnicode Standard Annex #31.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "criterion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "unicode-xid",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "exhaustive_tests",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/tests/exhaustive_tests.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xid",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/benches/xid.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "bench": [],
+                "default": [],
+                "no_std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "erick.tryzelaar <erick.tryzelaar@gmail.com>",
+                "kwantam <kwantam@gmail.com>",
+                "Manish Goregaokar <manishsmail@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "text",
+                "unicode",
+                "xid"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/unicode-rs/unicode-xid",
+            "homepage": "https://github.com/unicode-rs/unicode-xid",
+            "documentation": "https://unicode-rs.github.io/unicode-xid",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "value-bag",
+            "version": "1.0.0-alpha.7",
+            "id": "value-bag 1.0.0-alpha.7 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "Anonymous structured values",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "ctor",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "erased-serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": "erased-serde1",
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_fmt",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": "serde1_fmt",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": "serde1_lib",
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sval",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.5",
+                    "kind": null,
+                    "rename": "sval1_lib",
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [
+                        "fmt"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": "serde1_json",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": "serde1_test",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sval_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.5",
+                    "kind": "dev",
+                    "rename": "sval1_json",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "std"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sval",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0-alpha.5",
+                    "kind": "dev",
+                    "rename": "sval1_lib",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "test"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "wasm-bindgen",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "wasm-bindgen-test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "version_check",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": "build",
+                    "rename": "rustc",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "value-bag",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/value-bag-1.0.0-alpha.7/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/value-bag-1.0.0-alpha.7/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "error": [
+                    "std",
+                    "sval1_lib/std"
+                ],
+                "serde": [
+                    "serde1"
+                ],
+                "serde1": [
+                    "serde1_lib",
+                    "sval1_lib/serde1",
+                    "sval1_lib/alloc",
+                    "erased-serde1/alloc",
+                    "serde1_fmt"
+                ],
+                "std": [],
+                "sval": [
+                    "sval1"
+                ],
+                "sval1": [
+                    "sval1_lib"
+                ],
+                "test": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/value-bag-1.0.0-alpha.7/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "std",
+                            "error",
+                            "sval",
+                            "serde",
+                            "test"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Ashley Mannix <ashleymannix@live.com.au>"
+            ],
+            "categories": [
+                "encoding",
+                "no-std"
+            ],
+            "keywords": [
+                "serialization",
+                "no_std"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/sval-rs/value-bag",
+            "homepage": null,
+            "documentation": "https://docs.rs/value-bag",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "version_check",
+            "version": "0.9.4",
+            "id": "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Tiny crate to check the version of the installed/running rustc.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "version_check",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/version_check-0.9.4/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/version_check-0.9.4/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Sergio Benitez <sb@sergio.bz>"
+            ],
+            "categories": [],
+            "keywords": [
+                "version",
+                "rustc",
+                "minimum",
+                "check"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/SergioBenitez/version_check",
+            "homepage": null,
+            "documentation": "https://docs.rs/version_check/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "wasi",
+            "version": "0.10.2+wasi-snapshot-preview1",
+            "id": "wasi 0.10.2+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "Experimental WASI API bindings for Rust",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-alloc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "wasi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/wasi-0.10.2+wasi-snapshot-preview1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "rustc-dep-of-std": [
+                    "compiler_builtins",
+                    "core",
+                    "rustc-std-workspace-alloc"
+                ],
+                "std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/wasi-0.10.2+wasi-snapshot-preview1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "The Cranelift Project Developers"
+            ],
+            "categories": [
+                "no-std",
+                "wasm"
+            ],
+            "keywords": [
+                "webassembly",
+                "wasm"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/bytecodealliance/wasi",
+            "homepage": null,
+            "documentation": "https://docs.rs/wasi",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi",
+            "version": "0.3.9",
+            "id": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings for all of Windows API.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "winapi-i686-pc-windows-gnu",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "i686-pc-windows-gnu",
+                    "registry": null
+                },
+                {
+                    "name": "winapi-x86_64-pc-windows-gnu",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "x86_64-pc-windows-gnu",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "accctrl": [],
+                "aclapi": [],
+                "activation": [],
+                "adhoc": [],
+                "appmgmt": [],
+                "audioclient": [],
+                "audiosessiontypes": [],
+                "avrt": [],
+                "basetsd": [],
+                "bcrypt": [],
+                "bits": [],
+                "bits10_1": [],
+                "bits1_5": [],
+                "bits2_0": [],
+                "bits2_5": [],
+                "bits3_0": [],
+                "bits4_0": [],
+                "bits5_0": [],
+                "bitscfg": [],
+                "bitsmsg": [],
+                "bluetoothapis": [],
+                "bluetoothleapis": [],
+                "bthdef": [],
+                "bthioctl": [],
+                "bthledef": [],
+                "bthsdpdef": [],
+                "bugcodes": [],
+                "cderr": [],
+                "cfg": [],
+                "cfgmgr32": [],
+                "cguid": [],
+                "combaseapi": [],
+                "coml2api": [],
+                "commapi": [],
+                "commctrl": [],
+                "commdlg": [],
+                "commoncontrols": [],
+                "consoleapi": [],
+                "corecrt": [],
+                "corsym": [],
+                "d2d1": [],
+                "d2d1_1": [],
+                "d2d1_2": [],
+                "d2d1_3": [],
+                "d2d1effectauthor": [],
+                "d2d1effects": [],
+                "d2d1effects_1": [],
+                "d2d1effects_2": [],
+                "d2d1svg": [],
+                "d2dbasetypes": [],
+                "d3d": [],
+                "d3d10": [],
+                "d3d10_1": [],
+                "d3d10_1shader": [],
+                "d3d10effect": [],
+                "d3d10misc": [],
+                "d3d10sdklayers": [],
+                "d3d10shader": [],
+                "d3d11": [],
+                "d3d11_1": [],
+                "d3d11_2": [],
+                "d3d11_3": [],
+                "d3d11_4": [],
+                "d3d11on12": [],
+                "d3d11sdklayers": [],
+                "d3d11shader": [],
+                "d3d11tokenizedprogramformat": [],
+                "d3d12": [],
+                "d3d12sdklayers": [],
+                "d3d12shader": [],
+                "d3d9": [],
+                "d3d9caps": [],
+                "d3d9types": [],
+                "d3dcommon": [],
+                "d3dcompiler": [],
+                "d3dcsx": [],
+                "d3dkmdt": [],
+                "d3dkmthk": [],
+                "d3dukmdt": [],
+                "d3dx10core": [],
+                "d3dx10math": [],
+                "d3dx10mesh": [],
+                "datetimeapi": [],
+                "davclnt": [],
+                "dbghelp": [],
+                "dbt": [],
+                "dcommon": [],
+                "dcomp": [],
+                "dcompanimation": [],
+                "dcomptypes": [],
+                "dde": [],
+                "ddraw": [],
+                "ddrawi": [],
+                "ddrawint": [],
+                "debug": [
+                    "impl-debug"
+                ],
+                "debugapi": [],
+                "devguid": [],
+                "devicetopology": [],
+                "devpkey": [],
+                "devpropdef": [],
+                "dinput": [],
+                "dinputd": [],
+                "dispex": [],
+                "dmksctl": [],
+                "dmusicc": [],
+                "docobj": [],
+                "documenttarget": [],
+                "dot1x": [],
+                "dpa_dsa": [],
+                "dpapi": [],
+                "dsgetdc": [],
+                "dsound": [],
+                "dsrole": [],
+                "dvp": [],
+                "dwmapi": [],
+                "dwrite": [],
+                "dwrite_1": [],
+                "dwrite_2": [],
+                "dwrite_3": [],
+                "dxdiag": [],
+                "dxfile": [],
+                "dxgi": [],
+                "dxgi1_2": [],
+                "dxgi1_3": [],
+                "dxgi1_4": [],
+                "dxgi1_5": [],
+                "dxgi1_6": [],
+                "dxgidebug": [],
+                "dxgiformat": [],
+                "dxgitype": [],
+                "dxva2api": [],
+                "dxvahd": [],
+                "eaptypes": [],
+                "enclaveapi": [],
+                "endpointvolume": [],
+                "errhandlingapi": [],
+                "everything": [],
+                "evntcons": [],
+                "evntprov": [],
+                "evntrace": [],
+                "excpt": [],
+                "exdisp": [],
+                "fibersapi": [],
+                "fileapi": [],
+                "functiondiscoverykeys_devpkey": [],
+                "gl-gl": [],
+                "guiddef": [],
+                "handleapi": [],
+                "heapapi": [],
+                "hidclass": [],
+                "hidpi": [],
+                "hidsdi": [],
+                "hidusage": [],
+                "highlevelmonitorconfigurationapi": [],
+                "hstring": [],
+                "http": [],
+                "ifdef": [],
+                "ifmib": [],
+                "imm": [],
+                "impl-debug": [],
+                "impl-default": [],
+                "in6addr": [],
+                "inaddr": [],
+                "inspectable": [],
+                "interlockedapi": [],
+                "intsafe": [],
+                "ioapiset": [],
+                "ipexport": [],
+                "iphlpapi": [],
+                "ipifcons": [],
+                "ipmib": [],
+                "iprtrmib": [],
+                "iptypes": [],
+                "jobapi": [],
+                "jobapi2": [],
+                "knownfolders": [],
+                "ks": [],
+                "ksmedia": [],
+                "ktmtypes": [],
+                "ktmw32": [],
+                "l2cmn": [],
+                "libloaderapi": [],
+                "limits": [],
+                "lmaccess": [],
+                "lmalert": [],
+                "lmapibuf": [],
+                "lmat": [],
+                "lmcons": [],
+                "lmdfs": [],
+                "lmerrlog": [],
+                "lmjoin": [],
+                "lmmsg": [],
+                "lmremutl": [],
+                "lmrepl": [],
+                "lmserver": [],
+                "lmshare": [],
+                "lmstats": [],
+                "lmsvc": [],
+                "lmuse": [],
+                "lmwksta": [],
+                "lowlevelmonitorconfigurationapi": [],
+                "lsalookup": [],
+                "memoryapi": [],
+                "minschannel": [],
+                "minwinbase": [],
+                "minwindef": [],
+                "mmdeviceapi": [],
+                "mmeapi": [],
+                "mmreg": [],
+                "mmsystem": [],
+                "mprapidef": [],
+                "msaatext": [],
+                "mscat": [],
+                "mschapp": [],
+                "mssip": [],
+                "mstcpip": [],
+                "mswsock": [],
+                "mswsockdef": [],
+                "namedpipeapi": [],
+                "namespaceapi": [],
+                "nb30": [],
+                "ncrypt": [],
+                "netioapi": [],
+                "nldef": [],
+                "ntddndis": [],
+                "ntddscsi": [],
+                "ntddser": [],
+                "ntdef": [],
+                "ntlsa": [],
+                "ntsecapi": [],
+                "ntstatus": [],
+                "oaidl": [],
+                "objbase": [],
+                "objidl": [],
+                "objidlbase": [],
+                "ocidl": [],
+                "ole2": [],
+                "oleauto": [],
+                "olectl": [],
+                "oleidl": [],
+                "opmapi": [],
+                "pdh": [],
+                "perflib": [],
+                "physicalmonitorenumerationapi": [],
+                "playsoundapi": [],
+                "portabledevice": [],
+                "portabledeviceapi": [],
+                "portabledevicetypes": [],
+                "powerbase": [],
+                "powersetting": [],
+                "powrprof": [],
+                "processenv": [],
+                "processsnapshot": [],
+                "processthreadsapi": [],
+                "processtopologyapi": [],
+                "profileapi": [],
+                "propidl": [],
+                "propkey": [],
+                "propkeydef": [],
+                "propsys": [],
+                "prsht": [],
+                "psapi": [],
+                "qos": [],
+                "realtimeapiset": [],
+                "reason": [],
+                "restartmanager": [],
+                "restrictederrorinfo": [],
+                "rmxfguid": [],
+                "roapi": [],
+                "robuffer": [],
+                "roerrorapi": [],
+                "rpc": [],
+                "rpcdce": [],
+                "rpcndr": [],
+                "rtinfo": [],
+                "sapi": [],
+                "sapi51": [],
+                "sapi53": [],
+                "sapiddk": [],
+                "sapiddk51": [],
+                "schannel": [],
+                "sddl": [],
+                "securityappcontainer": [],
+                "securitybaseapi": [],
+                "servprov": [],
+                "setupapi": [],
+                "shellapi": [],
+                "shellscalingapi": [],
+                "shlobj": [],
+                "shobjidl": [],
+                "shobjidl_core": [],
+                "shtypes": [],
+                "softpub": [],
+                "spapidef": [],
+                "spellcheck": [],
+                "sporder": [],
+                "sql": [],
+                "sqlext": [],
+                "sqltypes": [],
+                "sqlucode": [],
+                "sspi": [],
+                "std": [],
+                "stralign": [],
+                "stringapiset": [],
+                "strmif": [],
+                "subauth": [],
+                "synchapi": [],
+                "sysinfoapi": [],
+                "systemtopologyapi": [],
+                "taskschd": [],
+                "tcpestats": [],
+                "tcpmib": [],
+                "textstor": [],
+                "threadpoolapiset": [],
+                "threadpoollegacyapiset": [],
+                "timeapi": [],
+                "timezoneapi": [],
+                "tlhelp32": [],
+                "transportsettingcommon": [],
+                "tvout": [],
+                "udpmib": [],
+                "unknwnbase": [],
+                "urlhist": [],
+                "urlmon": [],
+                "usb": [],
+                "usbioctl": [],
+                "usbiodef": [],
+                "usbscan": [],
+                "usbspec": [],
+                "userenv": [],
+                "usp10": [],
+                "utilapiset": [],
+                "uxtheme": [],
+                "vadefs": [],
+                "vcruntime": [],
+                "vsbackup": [],
+                "vss": [],
+                "vsserror": [],
+                "vswriter": [],
+                "wbemads": [],
+                "wbemcli": [],
+                "wbemdisp": [],
+                "wbemprov": [],
+                "wbemtran": [],
+                "wct": [],
+                "werapi": [],
+                "winbase": [],
+                "wincodec": [],
+                "wincodecsdk": [],
+                "wincon": [],
+                "wincontypes": [],
+                "wincred": [],
+                "wincrypt": [],
+                "windef": [],
+                "windot11": [],
+                "windowsceip": [],
+                "windowsx": [],
+                "winefs": [],
+                "winerror": [],
+                "winevt": [],
+                "wingdi": [],
+                "winhttp": [],
+                "wininet": [],
+                "winineti": [],
+                "winioctl": [],
+                "winnetwk": [],
+                "winnls": [],
+                "winnt": [],
+                "winreg": [],
+                "winsafer": [],
+                "winscard": [],
+                "winsmcrd": [],
+                "winsock2": [],
+                "winspool": [],
+                "winstring": [],
+                "winsvc": [],
+                "wintrust": [],
+                "winusb": [],
+                "winusbio": [],
+                "winuser": [],
+                "winver": [],
+                "wlanapi": [],
+                "wlanihv": [],
+                "wlanihvtypes": [],
+                "wlantypes": [],
+                "wlclient": [],
+                "wmistr": [],
+                "wnnc": [],
+                "wow64apiset": [],
+                "wpdmtpextensions": [],
+                "ws2bth": [],
+                "ws2def": [],
+                "ws2ipdef": [],
+                "ws2spi": [],
+                "ws2tcpip": [],
+                "wtsapi32": [],
+                "wtypes": [],
+                "wtypesbase": [],
+                "xinput": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-pc-windows-msvc",
+                        "features": [
+                            "everything",
+                            "impl-debug",
+                            "impl-default"
+                        ],
+                        "targets": [
+                            "aarch64-pc-windows-msvc",
+                            "i686-pc-windows-msvc",
+                            "x86_64-pc-windows-msvc"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os::windows-apis"
+            ],
+            "keywords": [
+                "windows",
+                "ffi",
+                "win32",
+                "com",
+                "directx"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/winapi/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi-i686-pc-windows-gnu",
+            "version": "0.4.0",
+            "id": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Import libraries for the i686-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi-i686-pc-windows-gnu",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "windows"
+            ],
+            "readme": null,
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi-util",
+            "version": "0.1.5",
+            "id": "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Unlicense/MIT",
+            "license_file": null,
+            "description": "A dumping ground for high level safe wrappers over winapi.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "winapi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "std",
+                        "consoleapi",
+                        "errhandlingapi",
+                        "fileapi",
+                        "minwindef",
+                        "processenv",
+                        "winbase",
+                        "wincon",
+                        "winerror",
+                        "winnt"
+                    ],
+                    "target": "cfg(windows)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi-util",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-util-0.1.5/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-util-0.1.5/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-pc-windows-msvc"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Andrew Gallant <jamslam@gmail.com>"
+            ],
+            "categories": [
+                "os::windows-apis",
+                "external-ffi-bindings"
+            ],
+            "keywords": [
+                "windows",
+                "winapi",
+                "util",
+                "win"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/BurntSushi/winapi-util",
+            "homepage": "https://github.com/BurntSushi/winapi-util",
+            "documentation": "https://docs.rs/winapi-util",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi-x86_64-pc-windows-gnu",
+            "version": "0.4.0",
+            "id": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Import libraries for the x86_64-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi-x86_64-pc-windows-gnu",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "windows"
+            ],
+            "readme": null,
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "aliases 0.1.0 (path+file://{TEMP_DIR}/aliases)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "aliases 0.1.0 (path+file://{TEMP_DIR}/aliases)",
+                "dependencies": [
+                    "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "names 0.12.1-dev (git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f)",
+                    "names 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "value-bag 1.0.0-alpha.7 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "pinned_log",
+                        "pkg": "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "log",
+                        "pkg": "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "pinned_names",
+                        "pkg": "names 0.12.1-dev (git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "names",
+                        "pkg": "names 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "value_bag",
+                        "pkg": "value-bag 1.0.0-alpha.7 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "hermit_abi",
+                        "pkg": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(target_os = \"hermit\")"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(unix)"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "winapi",
+                        "pkg": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(windows)"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "autocfg 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "clap_derive 3.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "indexmap 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "os_str_bytes 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "strsim 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "termcolor 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "textwrap 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "atty",
+                        "pkg": "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "bitflags",
+                        "pkg": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "clap_derive",
+                        "pkg": "clap_derive 3.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "indexmap",
+                        "pkg": "indexmap 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "lazy_static",
+                        "pkg": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "os_str_bytes",
+                        "pkg": "os_str_bytes 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "strsim",
+                        "pkg": "strsim 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "termcolor",
+                        "pkg": "termcolor 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "textwrap",
+                        "pkg": "textwrap 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "atty",
+                    "clap_derive",
+                    "color",
+                    "default",
+                    "derive",
+                    "lazy_static",
+                    "std",
+                    "strsim",
+                    "suggestions",
+                    "termcolor"
+                ]
+            },
+            {
+                "id": "clap_derive 3.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "heck 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "heck",
+                        "pkg": "heck 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "proc_macro_error",
+                        "pkg": "proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "syn",
+                        "pkg": "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "ctor 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "syn",
+                        "pkg": "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "getrandom 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "wasi 0.10.2+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(unix)"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "wasi",
+                        "pkg": "wasi 0.10.2+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(target_os = \"wasi\")"
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "std"
+                ]
+            },
+            {
+                "id": "hashbrown 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "raw"
+                ]
+            },
+            {
+                "id": "heck 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "indexmap 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "autocfg 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "hashbrown 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "autocfg",
+                        "pkg": "autocfg 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "hashbrown",
+                        "pkg": "hashbrown 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "std"
+                ]
+            },
+            {
+                "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "log",
+                        "pkg": "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "use_std"
+                ]
+            },
+            {
+                "id": "log 0.4.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "std"
+                ]
+            },
+            {
+                "id": "memchr 2.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "names 0.12.1-dev (git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f)",
+                "dependencies": [
+                    "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "clap",
+                        "pkg": "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rand",
+                        "pkg": "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "application",
+                    "clap",
+                    "default"
+                ]
+            },
+            {
+                "id": "names 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "clap",
+                        "pkg": "clap 3.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rand",
+                        "pkg": "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "application",
+                    "clap",
+                    "default"
+                ]
+            },
+            {
+                "id": "os_str_bytes 6.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "memchr 2.4.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "memchr",
+                        "pkg": "memchr 2.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "memchr",
+                    "raw_os_str"
+                ]
+            },
+            {
+                "id": "ppv-lite86 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "simd",
+                    "std"
+                ]
+            },
+            {
+                "id": "proc-macro-error 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro_error_attr",
+                        "pkg": "proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "syn",
+                        "pkg": "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "version_check",
+                        "pkg": "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "syn",
+                    "syn-error"
+                ]
+            },
+            {
+                "id": "proc-macro-error-attr 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "version_check",
+                        "pkg": "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "unicode_xid",
+                        "pkg": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "proc-macro"
+                ]
+            },
+            {
+                "id": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "proc-macro"
+                ]
+            },
+            {
+                "id": "rand 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rand_chacha 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.119 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(unix)"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rand_chacha",
+                        "pkg": "rand_chacha 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rand_core",
+                        "pkg": "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "alloc",
+                    "default",
+                    "getrandom",
+                    "libc",
+                    "rand_chacha",
+                    "std",
+                    "std_rng"
+                ]
+            },
+            {
+                "id": "rand_chacha 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "ppv-lite86 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "ppv_lite86",
+                        "pkg": "ppv-lite86 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rand_core",
+                        "pkg": "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "std"
+                ]
+            },
+            {
+                "id": "rand_core 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "getrandom 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "getrandom",
+                        "pkg": "getrandom 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "alloc",
+                    "getrandom",
+                    "std"
+                ]
+            },
+            {
+                "id": "strsim 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "unicode_xid",
+                        "pkg": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "clone-impls",
+                    "default",
+                    "derive",
+                    "full",
+                    "parsing",
+                    "printing",
+                    "proc-macro",
+                    "quote"
+                ]
+            },
+            {
+                "id": "termcolor 1.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "winapi_util",
+                        "pkg": "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(windows)"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "textwrap 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "value-bag 1.0.0-alpha.7 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "ctor 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "ctor",
+                        "pkg": "ctor 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rustc",
+                        "pkg": "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "version_check 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "wasi 0.10.2+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "winapi_i686_pc_windows_gnu",
+                        "pkg": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "i686-pc-windows-gnu"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "winapi_x86_64_pc_windows_gnu",
+                        "pkg": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "x86_64-pc-windows-gnu"
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "consoleapi",
+                    "errhandlingapi",
+                    "fileapi",
+                    "minwinbase",
+                    "minwindef",
+                    "processenv",
+                    "std",
+                    "winbase",
+                    "wincon",
+                    "winerror",
+                    "winnt"
+                ]
+            },
+            {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "winapi",
+                        "pkg": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(windows)"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            }
+        ],
+        "root": "aliases 0.1.0 (path+file://{TEMP_DIR}/aliases)"
+    },
+    "target_directory": "{TEMP_DIR}/aliases/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/aliases",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.lock
new file mode 100644
index 0000000..8b9b617
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.lock
@@ -0,0 +1,100 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "build-scripts"
+version = "0.1.0"
+dependencies = [
+ "openssl",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "libc"
+version = "0.2.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "openssl"
+version = "0.10.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d9facdb76fec0b73c406f125d44d86fdad818d66fef0531eec9233ca425ff4a"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e46109c383602735fa0a2e48dd2b7c892b048e1bf69e5c3b1d804b7d9c203cb"
+dependencies = [
+ "autocfg",
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.toml
new file mode 100644
index 0000000..99aaf5e
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "build-scripts"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+openssl = "=0.10.36"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/metadata.json
new file mode 100644
index 0000000..1f5a502
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/build_scripts/metadata.json
@@ -0,0 +1,1802 @@
+{
+    "packages": [
+        {
+            "name": "autocfg",
+            "version": "1.0.1",
+            "id": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "Automatic cfg for Rust compiler features",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "autocfg",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "integers",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/integers.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "paths",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/paths.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "versions",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/versions.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "traits",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/traits.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rustflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/tests/rustflags.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::build-utils"
+            ],
+            "keywords": [
+                "rustc",
+                "build",
+                "autoconf"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/cuviper/autocfg",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "bitflags",
+            "version": "1.3.2",
+            "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to generate structures which behave like bitflags.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "bitflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compile",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/compile.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "basic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/basic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "example_generated": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "example_generated"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "bit",
+                "bitmask",
+                "bitflags",
+                "flags"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/bitflags/bitflags",
+            "homepage": "https://github.com/bitflags/bitflags",
+            "documentation": "https://docs.rs/bitflags",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "build-scripts",
+            "version": "0.1.0",
+            "id": "build-scripts 0.1.0 (path+file://{TEMP_DIR}/build_scripts)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "openssl",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.10.36",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "build-scripts",
+                    "src_path": "{TEMP_DIR}/build_scripts/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/build_scripts/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "cc",
+            "version": "1.0.72",
+            "id": "cc 1.0.72 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A build-time dependency for Cargo build scripts to assist in invoking the native\nC compiler to compile native C code into a static archive to be linked into Rust\ncode.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "jobserver",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.16",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tempfile",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bin"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "gcc-shim",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/src/bin/gcc-shim.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cxxflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/tests/cxxflags.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/tests/cflags.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cc_env",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/tests/cc_env.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "parallel": [
+                    "jobserver"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cc-1.0.72/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [
+                "development-tools::build-utils"
+            ],
+            "keywords": [
+                "build-dependencies"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cc-rs",
+            "homepage": "https://github.com/alexcrichton/cc-rs",
+            "documentation": "https://docs.rs/cc",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "cfg-if",
+            "version": "1.0.0",
+            "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to ergonomically define an item depending on a large number of #[cfg]\nparameters. Structured like an if-else chain, the first matching branch is the\nitem that gets emitted.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cfg-if",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xcrate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/tests/xcrate.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cfg-if",
+            "homepage": "https://github.com/alexcrichton/cfg-if",
+            "documentation": "https://docs.rs/cfg-if",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "foreign-types",
+            "version": "0.3.2",
+            "id": "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A framework for Rust wrappers over C APIs",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "foreign-types-shared",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "foreign-types",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/foreign-types-0.3.2/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/foreign-types-0.3.2/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Steven Fackler <sfackler@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/sfackler/foreign-types",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "foreign-types-shared",
+            "version": "0.1.1",
+            "id": "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "An internal crate used by foreign-types",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "foreign-types-shared",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/foreign-types-shared-0.1.1/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/foreign-types-shared-0.1.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Steven Fackler <sfackler@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": "https://github.com/sfackler/foreign-types",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "libc",
+            "version": "0.2.112",
+            "id": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings to platform libraries like libc.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "libc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "const_fn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/tests/const_fn.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "align": [],
+                "const-extern-fn": [],
+                "default": [
+                    "std"
+                ],
+                "extra_traits": [],
+                "rustc-dep-of-std": [
+                    "align",
+                    "rustc-std-workspace-core"
+                ],
+                "std": [],
+                "use_std": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "const-extern-fn",
+                            "extra_traits"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os"
+            ],
+            "keywords": [
+                "libc",
+                "ffi",
+                "bindings",
+                "operating",
+                "system"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/libc",
+            "homepage": "https://github.com/rust-lang/libc",
+            "documentation": "https://docs.rs/libc/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "once_cell",
+            "version": "1.9.0",
+            "id": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Single assignment cells and lazy values.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "atomic-polyfill",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "parking_lot",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.11",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.7.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "once_cell",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench_acquire",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench_acquire.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench_vs_lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench_vs_lazy_static.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/lazy_static.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "reentrant_init_deadlocks",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/reentrant_init_deadlocks.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "regex",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/regex.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_synchronization",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/test_synchronization.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "it",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/tests/it.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "alloc": [
+                    "race"
+                ],
+                "default": [
+                    "std"
+                ],
+                "race": [],
+                "std": [
+                    "alloc"
+                ],
+                "unstable": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Aleksey Kladov <aleksey.kladov@gmail.com>"
+            ],
+            "categories": [
+                "rust-patterns",
+                "memory-management"
+            ],
+            "keywords": [
+                "lazy",
+                "static"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/matklad/once_cell",
+            "homepage": null,
+            "documentation": "https://docs.rs/once_cell",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "openssl",
+            "version": "0.10.36",
+            "id": "openssl 0.10.36 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0",
+            "license_file": null,
+            "description": "OpenSSL bindings",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "bitflags",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "openssl-sys",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9.66",
+                    "kind": null,
+                    "rename": "ffi",
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "foreign-types",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "once_cell",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.5.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "hex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tempdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "openssl",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-0.10.36/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "mk_certs",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-0.10.36/examples/mk_certs.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-0.10.36/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "v101": [],
+                "v102": [],
+                "v110": [],
+                "v111": [],
+                "vendored": [
+                    "ffi/vendored"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-0.10.36/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Steven Fackler <sfackler@gmail.com>"
+            ],
+            "categories": [
+                "cryptography",
+                "api-bindings"
+            ],
+            "keywords": [
+                "crypto",
+                "tls",
+                "ssl",
+                "dtls"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/sfackler/rust-openssl",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "openssl-sys",
+            "version": "0.9.72",
+            "id": "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "FFI bindings to OpenSSL",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "autocfg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "cc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "openssl-src",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^111",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "pkg-config",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.9",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "vcpkg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.8",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(target_env = \"msvc\")",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "openssl-sys",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-sys-0.9.72/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-main",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-sys-0.9.72/build/main.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "vendored": [
+                    "openssl-src"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/openssl-sys-0.9.72/Cargo.toml",
+            "metadata": {
+                "pkg-config": {
+                    "openssl": "1.0.1"
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>",
+                "Steven Fackler <sfackler@gmail.com>"
+            ],
+            "categories": [
+                "cryptography",
+                "external-ffi-bindings"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/sfackler/rust-openssl",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": "openssl",
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "pkg-config",
+            "version": "0.3.24",
+            "id": "pkg-config 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A library to run the pkg-config system tool at build time in order to be used in\nCargo build scripts.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "pkg-config",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pkg-config-0.3.24/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pkg-config-0.3.24/tests/test.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pkg-config-0.3.24/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "build-dependencies"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/pkg-config-rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/pkg-config",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "vcpkg",
+            "version": "0.2.15",
+            "id": "vcpkg 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A library to find native dependencies in a vcpkg tree at build\ntime in order to be used in Cargo build scripts.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tempdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.7",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "vcpkg",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/vcpkg-0.2.15/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/vcpkg-0.2.15/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Jim McGrath <jimmc2@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::build-utils"
+            ],
+            "keywords": [
+                "build-dependencies",
+                "windows",
+                "macos",
+                "linux"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/mcgoo/vcpkg-rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/vcpkg",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "build-scripts 0.1.0 (path+file://{TEMP_DIR}/build_scripts)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "build-scripts 0.1.0 (path+file://{TEMP_DIR}/build_scripts)",
+                "dependencies": [
+                    "openssl 0.10.36 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "openssl",
+                        "pkg": "openssl 0.10.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "cc 1.0.72 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "foreign_types_shared",
+                        "pkg": "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "alloc",
+                    "default",
+                    "race",
+                    "std"
+                ]
+            },
+            {
+                "id": "openssl 0.10.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "bitflags",
+                        "pkg": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "foreign_types",
+                        "pkg": "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "once_cell",
+                        "pkg": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "ffi",
+                        "pkg": "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "openssl-sys 0.9.72 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "cc 1.0.72 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "pkg-config 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "vcpkg 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "autocfg",
+                        "pkg": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "cc",
+                        "pkg": "cc 1.0.72 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "pkg_config",
+                        "pkg": "pkg-config 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "vcpkg",
+                        "pkg": "vcpkg 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": "cfg(target_env = \"msvc\")"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "pkg-config 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "vcpkg 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            }
+        ],
+        "root": "build-scripts 0.1.0 (path+file://{TEMP_DIR}/build_scripts)"
+    },
+    "target_directory": "{TEMP_DIR}/build_scripts/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/build_scripts",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.lock
new file mode 100644
index 0000000..e774515
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.lock
@@ -0,0 +1,23 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+]
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.toml
new file mode 100644
index 0000000..cabce4b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/common/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "common"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+[[bin]]
+name = "common-bin"
+path = "main.rs"
+
+[[test]]
+name = "common-test"
+path = "test.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bitflags = "=1.3.2"
+cfg-if = "=1.0.0"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/common/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/common/metadata.json
new file mode 100644
index 0000000..7118bf6
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/common/metadata.json
@@ -0,0 +1,431 @@
+{
+    "packages": [
+        {
+            "name": "bitflags",
+            "version": "1.3.2",
+            "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to generate structures which behave like bitflags.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "bitflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compile",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/compile.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "basic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/basic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "example_generated": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "example_generated"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "bit",
+                "bitmask",
+                "bitflags",
+                "flags"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/bitflags/bitflags",
+            "homepage": "https://github.com/bitflags/bitflags",
+            "documentation": "https://docs.rs/bitflags",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "cfg-if",
+            "version": "1.0.0",
+            "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to ergonomically define an item depending on a large number of #[cfg]\nparameters. Structured like an if-else chain, the first matching branch is the\nitem that gets emitted.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cfg-if",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xcrate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/tests/xcrate.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cfg-if",
+            "homepage": "https://github.com/alexcrichton/cfg-if",
+            "documentation": "https://docs.rs/cfg-if",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "common",
+            "version": "0.1.0",
+            "id": "common 0.1.0 (path+file://{TEMP_DIR}/common)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "bitflags",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.3.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "common",
+                    "src_path": "{TEMP_DIR}/common/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bin"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "common-bin",
+                    "src_path": "{TEMP_DIR}/common/main.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "common-test",
+                    "src_path": "{TEMP_DIR}/common/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/common/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "common 0.1.0 (path+file://{TEMP_DIR}/common)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "common 0.1.0 (path+file://{TEMP_DIR}/common)",
+                "dependencies": [
+                    "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "bitflags",
+                        "pkg": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            }
+        ],
+        "root": "common 0.1.0 (path+file://{TEMP_DIR}/common)"
+    },
+    "target_directory": "{TEMP_DIR}/common/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/common",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.lock
new file mode 100644
index 0000000..a949e76
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.lock
@@ -0,0 +1,208 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+
+[[package]]
+name = "crate-types"
+version = "0.1.0"
+dependencies = [
+ "bitflags",
+ "sysinfo",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97242a70df9b89a65d0b6df3c4bf5b9ce03c5b7309019777fbde37e7537f8762"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "lazy_static",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcae03edb34f947e64acdb1c33ec169824e20657e9ecb61cef6c8c74dcb8120"
+dependencies = [
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "rayon"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+dependencies = [
+ "autocfg",
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "lazy_static",
+ "num_cpus",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "sysinfo"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f1bfab07306a27332451a662ca9c8156e3a9986f82660ba9c8e744fe8455d43"
+dependencies = [
+ "cfg-if",
+ "core-foundation-sys",
+ "libc",
+ "ntapi",
+ "once_cell",
+ "rayon",
+ "winapi",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.toml
new file mode 100644
index 0000000..2b91734
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "crate-types"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bitflags = "=1.3.2"
+sysinfo = "=0.22.5"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/metadata.json
new file mode 100644
index 0000000..cf96826
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/crate_types/metadata.json
@@ -0,0 +1,4863 @@
+{
+    "packages": [
+        {
+            "name": "autocfg",
+            "version": "1.0.1",
+            "id": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "Automatic cfg for Rust compiler features",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "autocfg",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "integers",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/integers.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "paths",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/paths.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "versions",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/versions.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "traits",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/examples/traits.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rustflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/tests/rustflags.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/autocfg-1.0.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::build-utils"
+            ],
+            "keywords": [
+                "rustc",
+                "build",
+                "autoconf"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/cuviper/autocfg",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "bitflags",
+            "version": "1.3.2",
+            "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to generate structures which behave like bitflags.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_derive",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "bitflags",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compile",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/compile.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "basic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/tests/basic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "example_generated": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/bitflags-1.3.2/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "example_generated"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "bit",
+                "bitmask",
+                "bitflags",
+                "flags"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/bitflags/bitflags",
+            "homepage": "https://github.com/bitflags/bitflags",
+            "documentation": "https://docs.rs/bitflags",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "cfg-if",
+            "version": "1.0.0",
+            "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to ergonomically define an item depending on a large number of #[cfg]\nparameters. Structured like an if-else chain, the first matching branch is the\nitem that gets emitted.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cfg-if",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xcrate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/tests/xcrate.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cfg-if",
+            "homepage": "https://github.com/alexcrichton/cfg-if",
+            "documentation": "https://docs.rs/cfg-if",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "core-foundation-sys",
+            "version": "0.8.3",
+            "id": "core-foundation-sys 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT / Apache-2.0",
+            "license_file": null,
+            "description": "Bindings to Core Foundation for macOS",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "core-foundation-sys",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/core-foundation-sys-0.8.3/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/core-foundation-sys-0.8.3/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "mac_os_10_7_support": [],
+                "mac_os_10_8_features": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/core-foundation-sys-0.8.3/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-apple-darwin"
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Servo Project Developers"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": "https://github.com/servo/core-foundation-rs",
+            "homepage": "https://github.com/servo/core-foundation-rs",
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "crate-types",
+            "version": "0.1.0",
+            "id": "crate-types 0.1.0 (path+file://{TEMP_DIR}/crate_types)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "bitflags",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=1.3.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "sysinfo",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.22.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "crate-types",
+                    "src_path": "{TEMP_DIR}/crate_types/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/crate_types/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "crossbeam-channel",
+            "version": "0.5.2",
+            "id": "crossbeam-channel 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Multi-producer multi-consumer channels for message passing",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "num_cpus",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.13.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "signal-hook",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "crossbeam-channel",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "fibonacci",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/examples/fibonacci.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "matching",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/examples/matching.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "stopwatch",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/examples/stopwatch.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "same_channel",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/same_channel.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "zero",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/zero.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "after",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/after.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "never",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/never.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "list",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/list.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "iter",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/iter.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "mpsc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/mpsc.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "select_macro",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/select_macro.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "select",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/select.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "array",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/array.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "golang",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/golang.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "tick",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/tick.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "ready",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/ready.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "thread_locals",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/tests/thread_locals.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "crossbeam",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/benches/crossbeam.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "std": [
+                    "crossbeam-utils/std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-channel-0.5.2/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "algorithms",
+                "concurrency",
+                "data-structures"
+            ],
+            "keywords": [
+                "channel",
+                "mpmc",
+                "select",
+                "golang",
+                "message"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/crossbeam-rs/crossbeam",
+            "homepage": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-channel",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.36"
+        },
+        {
+            "name": "crossbeam-deque",
+            "version": "0.8.1",
+            "id": "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Concurrent work-stealing deque",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-epoch",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "crossbeam-deque",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "injector",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/tests/injector.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "fifo",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/tests/fifo.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "lifo",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/tests/lifo.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "steal",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/tests/steal.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "std": [
+                    "crossbeam-epoch/std",
+                    "crossbeam-utils/std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-deque-0.8.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "The Crossbeam Project Developers"
+            ],
+            "categories": [
+                "algorithms",
+                "concurrency",
+                "data-structures"
+            ],
+            "keywords": [
+                "chase-lev",
+                "lock-free",
+                "scheduler",
+                "scheduling"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/crossbeam-rs/crossbeam",
+            "homepage": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-deque",
+            "documentation": "https://docs.rs/crossbeam-deque",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "crossbeam-epoch",
+            "version": "0.9.6",
+            "id": "crossbeam-epoch 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Epoch-based garbage collection",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "const_fn",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.4.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "memoffset",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.6",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "scopeguard",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "loom",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5",
+                    "kind": null,
+                    "rename": "loom-crate",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(crossbeam_loom)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "crossbeam-epoch",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "sanitize",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/examples/sanitize.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "loom",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/tests/loom.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "pin",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/benches/pin.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "defer",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/benches/defer.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "flush",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/benches/flush.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "alloc": [],
+                "default": [
+                    "std"
+                ],
+                "loom": [
+                    "loom-crate",
+                    "crossbeam-utils/loom"
+                ],
+                "nightly": [
+                    "crossbeam-utils/nightly",
+                    "const_fn"
+                ],
+                "std": [
+                    "alloc",
+                    "crossbeam-utils/std",
+                    "lazy_static"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-epoch-0.9.6/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "concurrency",
+                "memory-management",
+                "no-std"
+            ],
+            "keywords": [
+                "lock-free",
+                "rcu",
+                "atomic",
+                "garbage"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/crossbeam-rs/crossbeam",
+            "homepage": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-epoch",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.36"
+        },
+        {
+            "name": "crossbeam-utils",
+            "version": "0.8.6",
+            "id": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Utilities for concurrent programming",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.4.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "loom",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(crossbeam_loom)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "crossbeam-utils",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "wait_group",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/wait_group.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "sharded_lock",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/sharded_lock.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "thread",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/thread.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cache_padded",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/cache_padded.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "atomic_cell",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/atomic_cell.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "parker",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/tests/parker.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "atomic_cell",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/benches/atomic_cell.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "std"
+                ],
+                "nightly": [],
+                "std": [
+                    "lazy_static"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/crossbeam-utils-0.8.6/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "algorithms",
+                "concurrency",
+                "data-structures",
+                "no-std"
+            ],
+            "keywords": [
+                "scoped",
+                "thread",
+                "atomic",
+                "cache"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/crossbeam-rs/crossbeam",
+            "homepage": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.36"
+        },
+        {
+            "name": "either",
+            "version": "1.6.1",
+            "id": "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde_json",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "either",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/either-1.6.1/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "use_std"
+                ],
+                "use_std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/either-1.6.1/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "serde"
+                        ]
+                    }
+                },
+                "release": {
+                    "no-dev-version": true,
+                    "tag-name": "{{version}}"
+                }
+            },
+            "publish": null,
+            "authors": [
+                "bluss"
+            ],
+            "categories": [
+                "data-structures",
+                "no-std"
+            ],
+            "keywords": [
+                "data-structure",
+                "no_std"
+            ],
+            "readme": "README-crates.io.md",
+            "repository": "https://github.com/bluss/either",
+            "homepage": null,
+            "documentation": "https://docs.rs/either/1/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "hermit-abi",
+            "version": "0.1.19",
+            "id": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "hermit-abi is small interface to call functions from the unikernel RustyHermit.\nIt is used to build the target `x86_64-unknown-hermit`.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.51",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "hermit-abi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hermit-abi-0.1.19/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [],
+                "docs": [],
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins/rustc-dep-of-std",
+                    "libc/rustc-dep-of-std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/hermit-abi-0.1.19/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-unknown-hermit",
+                        "features": [
+                            "docs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Stefan Lankes"
+            ],
+            "categories": [
+                "os"
+            ],
+            "keywords": [
+                "unikernel",
+                "libos"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/hermitcore/libhermit-rs",
+            "homepage": null,
+            "documentation": "https://hermitcore.github.io/rusty-hermit/hermit_abi",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "lazy_static",
+            "version": "1.4.0",
+            "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro for declaring lazily evaluated statics in Rust.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "spin",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "doc-comment",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/test.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "no_std",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/no_std.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "spin_no_std": [
+                    "spin"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Marvin L\u00f6bel <loebel.marvin@gmail.com>"
+            ],
+            "categories": [
+                "no-std",
+                "rust-patterns",
+                "memory-management"
+            ],
+            "keywords": [
+                "macro",
+                "lazy",
+                "static"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang-nursery/lazy-static.rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/lazy_static",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "libc",
+            "version": "0.2.112",
+            "id": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings to platform libraries like libc.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "libc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "const_fn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/tests/const_fn.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "align": [],
+                "const-extern-fn": [],
+                "default": [
+                    "std"
+                ],
+                "extra_traits": [],
+                "rustc-dep-of-std": [
+                    "align",
+                    "rustc-std-workspace-core"
+                ],
+                "std": [],
+                "use_std": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.112/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "const-extern-fn",
+                            "extra_traits"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os"
+            ],
+            "keywords": [
+                "libc",
+                "ffi",
+                "bindings",
+                "operating",
+                "system"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/libc",
+            "homepage": "https://github.com/rust-lang/libc",
+            "documentation": "https://docs.rs/libc/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "memoffset",
+            "version": "0.6.5",
+            "id": "memoffset 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "offset_of functionality for Rust structs.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "doc-comment",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "autocfg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "memoffset",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memoffset-0.6.5/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memoffset-0.6.5/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [],
+                "unstable_const": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/memoffset-0.6.5/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Gilad Naaman <gilad.naaman@gmail.com>"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "mem",
+                "offset",
+                "offset_of",
+                "offsetof"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/Gilnaa/memoffset",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "ntapi",
+            "version": "0.3.6",
+            "id": "ntapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "FFI bindings for Native API",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "winapi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "cfg",
+                        "evntrace",
+                        "in6addr",
+                        "inaddr",
+                        "minwinbase",
+                        "ntsecapi",
+                        "windef",
+                        "winioctl"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "ntapi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ntapi-0.3.6/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ntapi-0.3.6/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "user"
+                ],
+                "func-types": [],
+                "impl-default": [
+                    "winapi/impl-default"
+                ],
+                "kernel": [],
+                "nightly": [],
+                "user": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/ntapi-0.3.6/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-pc-windows-msvc",
+                        "features": [
+                            "nightly"
+                        ],
+                        "targets": [
+                            "aarch64-pc-windows-msvc",
+                            "i686-pc-windows-msvc",
+                            "x86_64-pc-windows-msvc"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "MSxDOS <melcodos@gmail.com>"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os::windows-apis"
+            ],
+            "keywords": [
+                "windows",
+                "ffi",
+                "ntapi",
+                "native",
+                "win32"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/MSxDOS/ntapi",
+            "homepage": null,
+            "documentation": "https://docs.rs/ntapi/*/x86_64-pc-windows-msvc/ntapi/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "num_cpus",
+            "version": "1.13.1",
+            "id": "num_cpus 1.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Get the number of CPUs on a machine.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "hermit-abi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))",
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.26",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(not(windows))",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "num_cpus",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/num_cpus-1.13.1/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "values",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/num_cpus-1.13.1/examples/values.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/num_cpus-1.13.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Sean McArthur <sean@seanmonstar.com>"
+            ],
+            "categories": [
+                "hardware-support"
+            ],
+            "keywords": [
+                "cpu",
+                "cpus",
+                "cores"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/seanmonstar/num_cpus",
+            "homepage": null,
+            "documentation": "https://docs.rs/num_cpus",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "once_cell",
+            "version": "1.9.0",
+            "id": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Single assignment cells and lazy values.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "atomic-polyfill",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "parking_lot",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.11",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.7.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "once_cell",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench_acquire",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench_acquire.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "bench_vs_lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/bench_vs_lazy_static.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/lazy_static.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "reentrant_init_deadlocks",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/reentrant_init_deadlocks.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "regex",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/regex.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_synchronization",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/examples/test_synchronization.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "std"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "it",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/tests/it.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "alloc": [
+                    "race"
+                ],
+                "default": [
+                    "std"
+                ],
+                "race": [],
+                "std": [
+                    "alloc"
+                ],
+                "unstable": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/once_cell-1.9.0/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Aleksey Kladov <aleksey.kladov@gmail.com>"
+            ],
+            "categories": [
+                "rust-patterns",
+                "memory-management"
+            ],
+            "keywords": [
+                "lazy",
+                "static"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/matklad/once_cell",
+            "homepage": null,
+            "documentation": "https://docs.rs/once_cell",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "rayon",
+            "version": "1.5.1",
+            "id": "rayon 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0/MIT",
+            "license_file": null,
+            "description": "Simple work-stealing parallelism for Rust",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "crossbeam-deque",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "either",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.9.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "docopt",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_xorshift",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "serde",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.85",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "derive"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "autocfg",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "build",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "rayon",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cpu_monitor",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/examples/cpu_monitor.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "sort-panic-safe",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/sort-panic-safe.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "producer_split_at",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/producer_split_at.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "clones",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/clones.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "issue671-unzip",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/issue671-unzip.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "issue671",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/issue671.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "str",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/str.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "cross-pool",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/cross-pool.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "collect",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/collect.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "iter_panic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/iter_panic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "octillion",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/octillion.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "intersperse",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/intersperse.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "named-threads",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/named-threads.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "debug",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/debug.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "chars",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/tests/chars.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-1.5.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Niko Matsakis <niko@alum.mit.edu>",
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "concurrency"
+            ],
+            "keywords": [
+                "parallel",
+                "thread",
+                "concurrency",
+                "join",
+                "performance"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rayon-rs/rayon",
+            "homepage": null,
+            "documentation": "https://docs.rs/rayon/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "rayon-core",
+            "version": "1.9.1",
+            "id": "rayon-core 1.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0/MIT",
+            "license_file": null,
+            "description": "Core APIs for Rayon",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "crossbeam-channel",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-deque",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "crossbeam-utils",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "num_cpus",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rand_xorshift",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "scoped-tls",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(unix)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "rayon-core",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "stack_overflow_crash",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/stack_overflow_crash.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "double_init_fail",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/double_init_fail.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "init_zero_threads",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/init_zero_threads.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "scope_join",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/scope_join.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "simple_panic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/simple_panic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "scoped_threadpool",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/tests/scoped_threadpool.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/rayon-core-1.9.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Niko Matsakis <niko@alum.mit.edu>",
+                "Josh Stone <cuviper@gmail.com>"
+            ],
+            "categories": [
+                "concurrency"
+            ],
+            "keywords": [
+                "parallel",
+                "thread",
+                "concurrency",
+                "join",
+                "performance"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rayon-rs/rayon",
+            "homepage": null,
+            "documentation": "https://docs.rs/rayon/",
+            "edition": "2018",
+            "links": "rayon-core",
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "scopeguard",
+            "version": "1.1.0",
+            "id": "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A RAII scope guard that will run a given closure when it goes out of scope,\neven if the code between panics (assuming unwinding panic).\n\nDefines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as\nshorthands for guards with one of the implemented strategies.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "scopeguard",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/scopeguard-1.1.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "readme",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/scopeguard-1.1.0/examples/readme.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "use_std"
+                ],
+                "use_std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/scopeguard-1.1.0/Cargo.toml",
+            "metadata": {
+                "release": {
+                    "no-dev-version": true
+                }
+            },
+            "publish": null,
+            "authors": [
+                "bluss"
+            ],
+            "categories": [
+                "rust-patterns",
+                "no-std"
+            ],
+            "keywords": [
+                "scope-guard",
+                "defer",
+                "panic",
+                "unwind"
+            ],
+            "readme": null,
+            "repository": "https://github.com/bluss/scopeguard",
+            "homepage": null,
+            "documentation": "https://docs.rs/scopeguard/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "sysinfo",
+            "version": "0.22.5",
+            "id": "sysinfo 0.22.5 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Library to get system information such as processes, processors, disks, components and networks",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "once_cell",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.5.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tempfile",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^3.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(all(target_os = \"linux\", not(target_os = \"android\")))",
+                    "registry": null
+                },
+                {
+                    "name": "core-foundation-sys",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.8",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(any(target_os = \"macos\", target_os = \"ios\"))",
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.112",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(not(any(target_os = \"unknown\", target_arch = \"wasm32\")))",
+                    "registry": null
+                },
+                {
+                    "name": "ntapi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(windows)",
+                    "registry": null
+                },
+                {
+                    "name": "winapi",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.9",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "fileapi",
+                        "handleapi",
+                        "ifdef",
+                        "ioapiset",
+                        "minwindef",
+                        "pdh",
+                        "psapi",
+                        "synchapi",
+                        "sysinfoapi",
+                        "winbase",
+                        "winerror",
+                        "winioctl",
+                        "winnt",
+                        "oleauto",
+                        "wbemcli",
+                        "rpcdce",
+                        "combaseapi",
+                        "objidl",
+                        "powerbase",
+                        "netioapi",
+                        "lmcons",
+                        "lmaccess",
+                        "lmapibuf",
+                        "memoryapi",
+                        "shellapi",
+                        "std"
+                    ],
+                    "target": "cfg(windows)",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "rlib",
+                        "cdylib"
+                    ],
+                    "crate_types": [
+                        "rlib",
+                        "cdylib"
+                    ],
+                    "name": "sysinfo",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "example"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "simple",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/examples/simple.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "processor",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/processor.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "send_sync",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/send_sync.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "extras",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/extras.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "uptime",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/uptime.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "disk_list",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/disk_list.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "process",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/process.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "network",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/tests/network.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "basic",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/benches/basic.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "apple-app-store": [
+                    "apple-sandbox"
+                ],
+                "apple-sandbox": [],
+                "c-interface": [],
+                "debug": [
+                    "libc/extra_traits"
+                ],
+                "default": [
+                    "multithread"
+                ],
+                "multithread": [
+                    "rayon"
+                ],
+                "unknown-ci": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/sysinfo-0.22.5/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Guillaume Gomez <guillaume1.gomez@gmail.com>"
+            ],
+            "categories": [
+                "filesystem",
+                "os",
+                "api-bindings"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/GuillaumeGomez/sysinfo",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.54"
+        },
+        {
+            "name": "winapi",
+            "version": "0.3.9",
+            "id": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings for all of Windows API.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "winapi-i686-pc-windows-gnu",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "i686-pc-windows-gnu",
+                    "registry": null
+                },
+                {
+                    "name": "winapi-x86_64-pc-windows-gnu",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "x86_64-pc-windows-gnu",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "accctrl": [],
+                "aclapi": [],
+                "activation": [],
+                "adhoc": [],
+                "appmgmt": [],
+                "audioclient": [],
+                "audiosessiontypes": [],
+                "avrt": [],
+                "basetsd": [],
+                "bcrypt": [],
+                "bits": [],
+                "bits10_1": [],
+                "bits1_5": [],
+                "bits2_0": [],
+                "bits2_5": [],
+                "bits3_0": [],
+                "bits4_0": [],
+                "bits5_0": [],
+                "bitscfg": [],
+                "bitsmsg": [],
+                "bluetoothapis": [],
+                "bluetoothleapis": [],
+                "bthdef": [],
+                "bthioctl": [],
+                "bthledef": [],
+                "bthsdpdef": [],
+                "bugcodes": [],
+                "cderr": [],
+                "cfg": [],
+                "cfgmgr32": [],
+                "cguid": [],
+                "combaseapi": [],
+                "coml2api": [],
+                "commapi": [],
+                "commctrl": [],
+                "commdlg": [],
+                "commoncontrols": [],
+                "consoleapi": [],
+                "corecrt": [],
+                "corsym": [],
+                "d2d1": [],
+                "d2d1_1": [],
+                "d2d1_2": [],
+                "d2d1_3": [],
+                "d2d1effectauthor": [],
+                "d2d1effects": [],
+                "d2d1effects_1": [],
+                "d2d1effects_2": [],
+                "d2d1svg": [],
+                "d2dbasetypes": [],
+                "d3d": [],
+                "d3d10": [],
+                "d3d10_1": [],
+                "d3d10_1shader": [],
+                "d3d10effect": [],
+                "d3d10misc": [],
+                "d3d10sdklayers": [],
+                "d3d10shader": [],
+                "d3d11": [],
+                "d3d11_1": [],
+                "d3d11_2": [],
+                "d3d11_3": [],
+                "d3d11_4": [],
+                "d3d11on12": [],
+                "d3d11sdklayers": [],
+                "d3d11shader": [],
+                "d3d11tokenizedprogramformat": [],
+                "d3d12": [],
+                "d3d12sdklayers": [],
+                "d3d12shader": [],
+                "d3d9": [],
+                "d3d9caps": [],
+                "d3d9types": [],
+                "d3dcommon": [],
+                "d3dcompiler": [],
+                "d3dcsx": [],
+                "d3dkmdt": [],
+                "d3dkmthk": [],
+                "d3dukmdt": [],
+                "d3dx10core": [],
+                "d3dx10math": [],
+                "d3dx10mesh": [],
+                "datetimeapi": [],
+                "davclnt": [],
+                "dbghelp": [],
+                "dbt": [],
+                "dcommon": [],
+                "dcomp": [],
+                "dcompanimation": [],
+                "dcomptypes": [],
+                "dde": [],
+                "ddraw": [],
+                "ddrawi": [],
+                "ddrawint": [],
+                "debug": [
+                    "impl-debug"
+                ],
+                "debugapi": [],
+                "devguid": [],
+                "devicetopology": [],
+                "devpkey": [],
+                "devpropdef": [],
+                "dinput": [],
+                "dinputd": [],
+                "dispex": [],
+                "dmksctl": [],
+                "dmusicc": [],
+                "docobj": [],
+                "documenttarget": [],
+                "dot1x": [],
+                "dpa_dsa": [],
+                "dpapi": [],
+                "dsgetdc": [],
+                "dsound": [],
+                "dsrole": [],
+                "dvp": [],
+                "dwmapi": [],
+                "dwrite": [],
+                "dwrite_1": [],
+                "dwrite_2": [],
+                "dwrite_3": [],
+                "dxdiag": [],
+                "dxfile": [],
+                "dxgi": [],
+                "dxgi1_2": [],
+                "dxgi1_3": [],
+                "dxgi1_4": [],
+                "dxgi1_5": [],
+                "dxgi1_6": [],
+                "dxgidebug": [],
+                "dxgiformat": [],
+                "dxgitype": [],
+                "dxva2api": [],
+                "dxvahd": [],
+                "eaptypes": [],
+                "enclaveapi": [],
+                "endpointvolume": [],
+                "errhandlingapi": [],
+                "everything": [],
+                "evntcons": [],
+                "evntprov": [],
+                "evntrace": [],
+                "excpt": [],
+                "exdisp": [],
+                "fibersapi": [],
+                "fileapi": [],
+                "functiondiscoverykeys_devpkey": [],
+                "gl-gl": [],
+                "guiddef": [],
+                "handleapi": [],
+                "heapapi": [],
+                "hidclass": [],
+                "hidpi": [],
+                "hidsdi": [],
+                "hidusage": [],
+                "highlevelmonitorconfigurationapi": [],
+                "hstring": [],
+                "http": [],
+                "ifdef": [],
+                "ifmib": [],
+                "imm": [],
+                "impl-debug": [],
+                "impl-default": [],
+                "in6addr": [],
+                "inaddr": [],
+                "inspectable": [],
+                "interlockedapi": [],
+                "intsafe": [],
+                "ioapiset": [],
+                "ipexport": [],
+                "iphlpapi": [],
+                "ipifcons": [],
+                "ipmib": [],
+                "iprtrmib": [],
+                "iptypes": [],
+                "jobapi": [],
+                "jobapi2": [],
+                "knownfolders": [],
+                "ks": [],
+                "ksmedia": [],
+                "ktmtypes": [],
+                "ktmw32": [],
+                "l2cmn": [],
+                "libloaderapi": [],
+                "limits": [],
+                "lmaccess": [],
+                "lmalert": [],
+                "lmapibuf": [],
+                "lmat": [],
+                "lmcons": [],
+                "lmdfs": [],
+                "lmerrlog": [],
+                "lmjoin": [],
+                "lmmsg": [],
+                "lmremutl": [],
+                "lmrepl": [],
+                "lmserver": [],
+                "lmshare": [],
+                "lmstats": [],
+                "lmsvc": [],
+                "lmuse": [],
+                "lmwksta": [],
+                "lowlevelmonitorconfigurationapi": [],
+                "lsalookup": [],
+                "memoryapi": [],
+                "minschannel": [],
+                "minwinbase": [],
+                "minwindef": [],
+                "mmdeviceapi": [],
+                "mmeapi": [],
+                "mmreg": [],
+                "mmsystem": [],
+                "mprapidef": [],
+                "msaatext": [],
+                "mscat": [],
+                "mschapp": [],
+                "mssip": [],
+                "mstcpip": [],
+                "mswsock": [],
+                "mswsockdef": [],
+                "namedpipeapi": [],
+                "namespaceapi": [],
+                "nb30": [],
+                "ncrypt": [],
+                "netioapi": [],
+                "nldef": [],
+                "ntddndis": [],
+                "ntddscsi": [],
+                "ntddser": [],
+                "ntdef": [],
+                "ntlsa": [],
+                "ntsecapi": [],
+                "ntstatus": [],
+                "oaidl": [],
+                "objbase": [],
+                "objidl": [],
+                "objidlbase": [],
+                "ocidl": [],
+                "ole2": [],
+                "oleauto": [],
+                "olectl": [],
+                "oleidl": [],
+                "opmapi": [],
+                "pdh": [],
+                "perflib": [],
+                "physicalmonitorenumerationapi": [],
+                "playsoundapi": [],
+                "portabledevice": [],
+                "portabledeviceapi": [],
+                "portabledevicetypes": [],
+                "powerbase": [],
+                "powersetting": [],
+                "powrprof": [],
+                "processenv": [],
+                "processsnapshot": [],
+                "processthreadsapi": [],
+                "processtopologyapi": [],
+                "profileapi": [],
+                "propidl": [],
+                "propkey": [],
+                "propkeydef": [],
+                "propsys": [],
+                "prsht": [],
+                "psapi": [],
+                "qos": [],
+                "realtimeapiset": [],
+                "reason": [],
+                "restartmanager": [],
+                "restrictederrorinfo": [],
+                "rmxfguid": [],
+                "roapi": [],
+                "robuffer": [],
+                "roerrorapi": [],
+                "rpc": [],
+                "rpcdce": [],
+                "rpcndr": [],
+                "rtinfo": [],
+                "sapi": [],
+                "sapi51": [],
+                "sapi53": [],
+                "sapiddk": [],
+                "sapiddk51": [],
+                "schannel": [],
+                "sddl": [],
+                "securityappcontainer": [],
+                "securitybaseapi": [],
+                "servprov": [],
+                "setupapi": [],
+                "shellapi": [],
+                "shellscalingapi": [],
+                "shlobj": [],
+                "shobjidl": [],
+                "shobjidl_core": [],
+                "shtypes": [],
+                "softpub": [],
+                "spapidef": [],
+                "spellcheck": [],
+                "sporder": [],
+                "sql": [],
+                "sqlext": [],
+                "sqltypes": [],
+                "sqlucode": [],
+                "sspi": [],
+                "std": [],
+                "stralign": [],
+                "stringapiset": [],
+                "strmif": [],
+                "subauth": [],
+                "synchapi": [],
+                "sysinfoapi": [],
+                "systemtopologyapi": [],
+                "taskschd": [],
+                "tcpestats": [],
+                "tcpmib": [],
+                "textstor": [],
+                "threadpoolapiset": [],
+                "threadpoollegacyapiset": [],
+                "timeapi": [],
+                "timezoneapi": [],
+                "tlhelp32": [],
+                "transportsettingcommon": [],
+                "tvout": [],
+                "udpmib": [],
+                "unknwnbase": [],
+                "urlhist": [],
+                "urlmon": [],
+                "usb": [],
+                "usbioctl": [],
+                "usbiodef": [],
+                "usbscan": [],
+                "usbspec": [],
+                "userenv": [],
+                "usp10": [],
+                "utilapiset": [],
+                "uxtheme": [],
+                "vadefs": [],
+                "vcruntime": [],
+                "vsbackup": [],
+                "vss": [],
+                "vsserror": [],
+                "vswriter": [],
+                "wbemads": [],
+                "wbemcli": [],
+                "wbemdisp": [],
+                "wbemprov": [],
+                "wbemtran": [],
+                "wct": [],
+                "werapi": [],
+                "winbase": [],
+                "wincodec": [],
+                "wincodecsdk": [],
+                "wincon": [],
+                "wincontypes": [],
+                "wincred": [],
+                "wincrypt": [],
+                "windef": [],
+                "windot11": [],
+                "windowsceip": [],
+                "windowsx": [],
+                "winefs": [],
+                "winerror": [],
+                "winevt": [],
+                "wingdi": [],
+                "winhttp": [],
+                "wininet": [],
+                "winineti": [],
+                "winioctl": [],
+                "winnetwk": [],
+                "winnls": [],
+                "winnt": [],
+                "winreg": [],
+                "winsafer": [],
+                "winscard": [],
+                "winsmcrd": [],
+                "winsock2": [],
+                "winspool": [],
+                "winstring": [],
+                "winsvc": [],
+                "wintrust": [],
+                "winusb": [],
+                "winusbio": [],
+                "winuser": [],
+                "winver": [],
+                "wlanapi": [],
+                "wlanihv": [],
+                "wlanihvtypes": [],
+                "wlantypes": [],
+                "wlclient": [],
+                "wmistr": [],
+                "wnnc": [],
+                "wow64apiset": [],
+                "wpdmtpextensions": [],
+                "ws2bth": [],
+                "ws2def": [],
+                "ws2ipdef": [],
+                "ws2spi": [],
+                "ws2tcpip": [],
+                "wtsapi32": [],
+                "wtypes": [],
+                "wtypesbase": [],
+                "xinput": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-0.3.9/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "default-target": "x86_64-pc-windows-msvc",
+                        "features": [
+                            "everything",
+                            "impl-debug",
+                            "impl-default"
+                        ],
+                        "targets": [
+                            "aarch64-pc-windows-msvc",
+                            "i686-pc-windows-msvc",
+                            "x86_64-pc-windows-msvc"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os::windows-apis"
+            ],
+            "keywords": [
+                "windows",
+                "ffi",
+                "win32",
+                "com",
+                "directx"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/winapi/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi-i686-pc-windows-gnu",
+            "version": "0.4.0",
+            "id": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Import libraries for the i686-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi-i686-pc-windows-gnu",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-i686-pc-windows-gnu-0.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "windows"
+            ],
+            "readme": null,
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "winapi-x86_64-pc-windows-gnu",
+            "version": "0.4.0",
+            "id": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "Import libraries for the x86_64-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "winapi-x86_64-pc-windows-gnu",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/winapi-x86_64-pc-windows-gnu-0.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Peter Atashian <retep998@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "windows"
+            ],
+            "readme": null,
+            "repository": "https://github.com/retep998/winapi-rs",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "crate-types 0.1.0 (path+file://{TEMP_DIR}/crate_types)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "core-foundation-sys 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "crate-types 0.1.0 (path+file://{TEMP_DIR}/crate_types)",
+                "dependencies": [
+                    "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "sysinfo 0.22.5 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "bitflags",
+                        "pkg": "bitflags 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "sysinfo",
+                        "pkg": "sysinfo 0.22.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "crossbeam-channel 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_utils",
+                        "pkg": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "crossbeam-utils",
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-epoch 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_epoch",
+                        "pkg": "crossbeam-epoch 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_utils",
+                        "pkg": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "crossbeam-epoch",
+                    "crossbeam-utils",
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "crossbeam-epoch 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "memoffset 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_utils",
+                        "pkg": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "lazy_static",
+                        "pkg": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "memoffset",
+                        "pkg": "memoffset 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "scopeguard",
+                        "pkg": "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "alloc",
+                    "lazy_static",
+                    "std"
+                ]
+            },
+            {
+                "id": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "lazy_static",
+                        "pkg": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "lazy_static",
+                    "std"
+                ]
+            },
+            {
+                "id": "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "memoffset 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "autocfg",
+                        "pkg": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default"
+                ]
+            },
+            {
+                "id": "ntapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "winapi",
+                        "pkg": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "user"
+                ]
+            },
+            {
+                "id": "num_cpus 1.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "hermit_abi",
+                        "pkg": "hermit-abi 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(not(windows))"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "alloc",
+                    "default",
+                    "race",
+                    "std"
+                ]
+            },
+            {
+                "id": "rayon 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rayon-core 1.9.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "autocfg",
+                        "pkg": "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": "build",
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_deque",
+                        "pkg": "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "either",
+                        "pkg": "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rayon_core",
+                        "pkg": "rayon-core 1.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "rayon-core 1.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "crossbeam-channel 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "num_cpus 1.13.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "crossbeam_channel",
+                        "pkg": "crossbeam-channel 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_deque",
+                        "pkg": "crossbeam-deque 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "crossbeam_utils",
+                        "pkg": "crossbeam-utils 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "lazy_static",
+                        "pkg": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "num_cpus",
+                        "pkg": "num_cpus 1.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "sysinfo 0.22.5 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "core-foundation-sys 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "ntapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "rayon 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "core_foundation_sys",
+                        "pkg": "core-foundation-sys 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(any(target_os = \"macos\", target_os = \"ios\"))"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.112 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(not(any(target_os = \"unknown\", target_arch = \"wasm32\")))"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "ntapi",
+                        "pkg": "ntapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(windows)"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "once_cell",
+                        "pkg": "once_cell 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "rayon",
+                        "pkg": "rayon 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "winapi",
+                        "pkg": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "cfg(windows)"
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "multithread",
+                    "rayon"
+                ]
+            },
+            {
+                "id": "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "winapi_i686_pc_windows_gnu",
+                        "pkg": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "i686-pc-windows-gnu"
+                            }
+                        ]
+                    },
+                    {
+                        "name": "winapi_x86_64_pc_windows_gnu",
+                        "pkg": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "x86_64-pc-windows-gnu"
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "cfg",
+                    "combaseapi",
+                    "evntrace",
+                    "fileapi",
+                    "handleapi",
+                    "ifdef",
+                    "in6addr",
+                    "inaddr",
+                    "ioapiset",
+                    "lmaccess",
+                    "lmapibuf",
+                    "lmcons",
+                    "memoryapi",
+                    "minwinbase",
+                    "minwindef",
+                    "netioapi",
+                    "ntsecapi",
+                    "objidl",
+                    "oleauto",
+                    "pdh",
+                    "powerbase",
+                    "psapi",
+                    "rpcdce",
+                    "shellapi",
+                    "std",
+                    "synchapi",
+                    "sysinfoapi",
+                    "wbemcli",
+                    "winbase",
+                    "windef",
+                    "winerror",
+                    "winioctl",
+                    "winnt"
+                ]
+            },
+            {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            }
+        ],
+        "root": "crate-types 0.1.0 (path+file://{TEMP_DIR}/crate_types)"
+    },
+    "target_directory": "{TEMP_DIR}/crate_types/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/crate_types",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.lock
new file mode 100644
index 0000000..58405f4
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.lock
@@ -0,0 +1,92 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "git-repos"
+version = "0.1.0"
+dependencies = [
+ "tracing",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tracing"
+version = "0.2.0"
+source = "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0"
+dependencies = [
+ "cfg-if",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.2.0"
+source = "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.2.0"
+source = "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.toml
new file mode 100644
index 0000000..6516f98
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "git-repos"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+[dependencies]
+tracing = { git = "https://github.com/tokio-rs/tracing.git", rev = "1e09e50e8d15580b5929adbade9c782a6833e4a0" }
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/metadata.json
new file mode 100644
index 0000000..29140fc
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/git_repos/metadata.json
@@ -0,0 +1,2642 @@
+{
+    "packages": [
+        {
+            "name": "cfg-if",
+            "version": "1.0.0",
+            "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro to ergonomically define an item depending on a large number of #[cfg]\nparameters. Structured like an if-else chain, the first matching branch is the\nitem that gets emitted.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "compiler_builtins",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": "core",
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cfg-if",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xcrate",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/tests/xcrate.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "rustc-dep-of-std": [
+                    "core",
+                    "compiler_builtins"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cfg-if-1.0.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/alexcrichton/cfg-if",
+            "homepage": "https://github.com/alexcrichton/cfg-if",
+            "documentation": "https://docs.rs/cfg-if",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "git-repos",
+            "version": "0.1.0",
+            "id": "git-repos 0.1.0 (path+file://{TEMP_DIR}/git_repos)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "tracing",
+                    "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0",
+                    "req": "*",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "git-repos",
+                    "src_path": "{TEMP_DIR}/git_repos/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/git_repos/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "lazy_static",
+            "version": "1.4.0",
+            "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT/Apache-2.0",
+            "license_file": null,
+            "description": "A macro for declaring lazily evaluated statics in Rust.",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "spin",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.5.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "doc-comment",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "lazy_static",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/test.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "no_std",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/tests/no_std.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "spin_no_std": [
+                    "spin"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.4.0/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Marvin L\u00f6bel <loebel.marvin@gmail.com>"
+            ],
+            "categories": [
+                "no-std",
+                "rust-patterns",
+                "memory-management"
+            ],
+            "keywords": [
+                "macro",
+                "lazy",
+                "static"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang-nursery/lazy-static.rs",
+            "homepage": null,
+            "documentation": "https://docs.rs/lazy_static",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "pin-project-lite",
+            "version": "0.2.8",
+            "id": "pin-project-lite 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "Apache-2.0 OR MIT",
+            "license_file": null,
+            "description": "A lightweight version of pin-project written with declarative macros.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "macrotest",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.8",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "static_assertions",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.49",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "pin-project-lite",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "proper_unpin",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/proper_unpin.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "drop_order",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/drop_order.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "expandtest",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/expandtest.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "lint",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/lint.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compiletest",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/tests/compiletest.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/pin-project-lite-0.2.8/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [],
+            "categories": [
+                "no-std",
+                "rust-patterns"
+            ],
+            "keywords": [
+                "pin",
+                "macros"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/taiki-e/pin-project-lite",
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.37"
+        },
+        {
+            "name": "proc-macro2",
+            "version": "1.0.36",
+            "id": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "A substitute implementation of the compiler's `proc_macro` API to decouple\ntoken-based libraries from the procedural macro use case.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "unicode-xid",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "proc-macro2",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "features",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/features.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_fmt",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/test_fmt.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "comments",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/comments.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "marker",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/tests/marker.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "default": [
+                    "proc-macro"
+                ],
+                "nightly": [],
+                "proc-macro": [],
+                "span-locations": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.36/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "rustc-args": [
+                            "--cfg",
+                            "procmacro2_semver_exempt"
+                        ],
+                        "rustdoc-args": [
+                            "--cfg",
+                            "procmacro2_semver_exempt",
+                            "--cfg",
+                            "doc_cfg"
+                        ],
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "span-locations"
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>",
+                "Alex Crichton <alex@alexcrichton.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "macros"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/proc-macro2",
+            "homepage": null,
+            "documentation": "https://docs.rs/proc-macro2",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "quote",
+            "version": "1.0.14",
+            "id": "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Quasi-quoting macro quote!(...)",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.36",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rustversion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "trybuild",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.52",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "diff"
+                    ],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "quote",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.14/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.14/tests/test.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "compiletest",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.14/tests/compiletest.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "default": [
+                    "proc-macro"
+                ],
+                "proc-macro": [
+                    "proc-macro2/proc-macro"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/quote-1.0.14/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [
+                "syn"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/quote",
+            "homepage": null,
+            "documentation": "https://docs.rs/quote/",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "syn",
+            "version": "1.0.85",
+            "id": "syn 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Parser for Rust source code",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.32",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "unicode-xid",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "anyhow",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "automod",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "flate2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "insta",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "rayon",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "ref-cast",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "regex",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "reqwest",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.11",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "blocking"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn-test-suite",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tar",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4.16",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "termcolor",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "walkdir",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^2.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "syn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_should_parse",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_should_parse.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_visibility",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_visibility.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_stmt",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_stmt.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_round_trip",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_round_trip.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_size",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_size.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_shebang",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_shebang.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_pat",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_pat.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_receiver",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_receiver.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_precedence",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_precedence.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_lit",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_lit.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "regression",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/regression.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_parse_stream",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_parse_stream.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_grouping",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_grouping.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_ident",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_ident.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_iterators",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_iterators.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_parse_buffer",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_parse_buffer.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_asyncness",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_asyncness.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_token_trees",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_token_trees.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_ty",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_ty.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "zzz_stable",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/zzz_stable.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_meta",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_meta.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_expr",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_expr.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_item",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_item.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_path",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_path.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_derive_input",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_derive_input.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_generics",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_generics.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "test_attribute",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/tests/test_attribute.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "rust",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/benches/rust.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "full",
+                        "parsing"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "file",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/benches/file.rs",
+                    "edition": "2018",
+                    "required-features": [
+                        "full",
+                        "parsing"
+                    ],
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/build.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "clone-impls": [],
+                "default": [
+                    "derive",
+                    "parsing",
+                    "printing",
+                    "clone-impls",
+                    "proc-macro"
+                ],
+                "derive": [],
+                "extra-traits": [],
+                "fold": [],
+                "full": [],
+                "parsing": [],
+                "printing": [
+                    "quote"
+                ],
+                "proc-macro": [
+                    "proc-macro2/proc-macro",
+                    "quote/proc-macro"
+                ],
+                "test": [
+                    "syn-test-suite/all-features"
+                ],
+                "visit": [],
+                "visit-mut": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/syn-1.0.85/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "doc_cfg"
+                        ],
+                        "targets": [
+                            "x86_64-unknown-linux-gnu"
+                        ]
+                    }
+                },
+                "playground": {
+                    "features": [
+                        "full",
+                        "visit",
+                        "visit-mut",
+                        "fold",
+                        "extra-traits"
+                    ]
+                }
+            },
+            "publish": null,
+            "authors": [
+                "David Tolnay <dtolnay@gmail.com>"
+            ],
+            "categories": [
+                "development-tools::procedural-macro-helpers"
+            ],
+            "keywords": [],
+            "readme": "README.md",
+            "repository": "https://github.com/dtolnay/syn",
+            "homepage": null,
+            "documentation": "https://docs.rs/syn",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": "1.31"
+        },
+        {
+            "name": "tracing",
+            "version": "0.2.0",
+            "id": "tracing 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Application-level tracing for Rust.\n",
+            "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+            "dependencies": [
+                {
+                    "name": "cfg-if",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "pin-project-lite",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tracing-attributes",
+                    "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tracing-core",
+                    "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+                    "req": "^0.2",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "criterion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "futures",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "log",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.4",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tokio",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.21",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [
+                        "rt-core"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "wasm-bindgen-test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(target_arch = \"wasm32\")",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "tracing",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "collector",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/collector.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "max_level_hint",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/max_level_hint.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "filter_caching_is_lexically_scoped",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/filter_caching_is_lexically_scoped.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "filters_dont_leak",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/filters_dont_leak.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "filters_are_reevaluated_for_different_call_sites",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/filters_are_reevaluated_for_different_call_sites.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "event",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/event.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "multiple_max_level_hints",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/multiple_max_level_hints.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "filters_are_not_reevaluated_for_the_same_span",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/filters_are_not_reevaluated_for_the_same_span.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "span",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/span.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macro_imports",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/macro_imports.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macros",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/tests/macros.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "subscriber",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/benches/subscriber.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "no_subscriber",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/benches/no_subscriber.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "global_subscriber",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/benches/global_subscriber.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "alloc": [
+                    "tracing-core/alloc"
+                ],
+                "attributes": [
+                    "tracing-attributes"
+                ],
+                "default": [
+                    "std",
+                    "attributes"
+                ],
+                "log-always": [
+                    "log"
+                ],
+                "max_level_debug": [],
+                "max_level_error": [],
+                "max_level_info": [],
+                "max_level_off": [],
+                "max_level_trace": [],
+                "max_level_warn": [],
+                "release_max_level_debug": [],
+                "release_max_level_error": [],
+                "release_max_level_info": [],
+                "release_max_level_off": [],
+                "release_max_level_trace": [],
+                "release_max_level_warn": [],
+                "std": [
+                    "tracing-core/std",
+                    "alloc"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "docsrs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Eliza Weisman <eliza@buoyant.io>",
+                "Tokio Contributors <team@tokio.rs>"
+            ],
+            "categories": [
+                "development-tools::debugging",
+                "development-tools::profiling",
+                "asynchronous",
+                "no-std"
+            ],
+            "keywords": [
+                "logging",
+                "tracing",
+                "metrics",
+                "async"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/tokio-rs/tracing",
+            "homepage": "https://tokio.rs",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "tracing-attributes",
+            "version": "0.2.0",
+            "id": "tracing-attributes 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Procedural macro attributes for automatically instrumenting functions.\n",
+            "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+            "dependencies": [
+                {
+                    "name": "proc-macro2",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "quote",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "syn",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": false,
+                    "features": [
+                        "full",
+                        "parsing",
+                        "printing",
+                        "visit",
+                        "visit-mut",
+                        "clone-impls",
+                        "extra-traits",
+                        "proc-macro"
+                    ],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "async-trait",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.1.44",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tokio-test",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.0",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tracing",
+                    "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+                    "req": "^0.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                },
+                {
+                    "name": "tracing-core",
+                    "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+                    "req": "^0.2",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "proc-macro"
+                    ],
+                    "crate_types": [
+                        "proc-macro"
+                    ],
+                    "name": "tracing-attributes",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "async_fn",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/async_fn.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "targets",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/targets.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "support",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/support.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "fields",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/fields.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "destructuring",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/destructuring.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "err",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/err.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "levels",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/levels.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "instrument",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/instrument.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "names",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/tests/names.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-attributes/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "Tokio Contributors <team@tokio.rs>",
+                "Eliza Weisman <eliza@buoyant.io>",
+                "David Barsky <dbarsky@amazon.com>"
+            ],
+            "categories": [
+                "development-tools::debugging",
+                "development-tools::profiling",
+                "asynchronous"
+            ],
+            "keywords": [
+                "logging",
+                "tracing",
+                "macro",
+                "instrument",
+                "log"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/tokio-rs/tracing",
+            "homepage": "https://tokio.rs",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "tracing-core",
+            "version": "0.2.0",
+            "id": "tracing-core 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+            "license": "MIT",
+            "license_file": null,
+            "description": "Core primitives for application-level tracing.\n",
+            "source": "git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0",
+            "dependencies": [
+                {
+                    "name": "lazy_static",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "tracing-core",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-core/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "dispatch",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-core/tests/dispatch.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "macros",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-core/tests/macros.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "global_dispatch",
+                    "src_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-core/tests/global_dispatch.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {
+                "alloc": [],
+                "default": [
+                    "std"
+                ],
+                "std": [
+                    "lazy_static",
+                    "alloc"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/git/checkouts/tracing-e9bbb56ea31f0c18/1e09e50/tracing-core/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "all-features": true,
+                        "rustdoc-args": [
+                            "--cfg",
+                            "docsrs"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "Tokio Contributors <team@tokio.rs>"
+            ],
+            "categories": [
+                "development-tools::debugging",
+                "development-tools::profiling",
+                "asynchronous"
+            ],
+            "keywords": [
+                "logging",
+                "tracing",
+                "profiling"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/tokio-rs/tracing",
+            "homepage": "https://tokio.rs",
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "unicode-xid",
+            "version": "0.2.2",
+            "id": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Determine whether characters have the XID_Start\nor XID_Continue properties according to\nUnicode Standard Annex #31.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "criterion",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.3",
+                    "kind": "dev",
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "unicode-xid",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "exhaustive_tests",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/tests/exhaustive_tests.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "bench"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "xid",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/benches/xid.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "bench": [],
+                "default": [],
+                "no_std": []
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/unicode-xid-0.2.2/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "erick.tryzelaar <erick.tryzelaar@gmail.com>",
+                "kwantam <kwantam@gmail.com>",
+                "Manish Goregaokar <manishsmail@gmail.com>"
+            ],
+            "categories": [],
+            "keywords": [
+                "text",
+                "unicode",
+                "xid"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/unicode-rs/unicode-xid",
+            "homepage": "https://github.com/unicode-rs/unicode-xid",
+            "documentation": "https://unicode-rs.github.io/unicode-xid",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "git-repos 0.1.0 (path+file://{TEMP_DIR}/git_repos)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "git-repos 0.1.0 (path+file://{TEMP_DIR}/git_repos)",
+                "dependencies": [
+                    "tracing 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)"
+                ],
+                "deps": [
+                    {
+                        "name": "tracing",
+                        "pkg": "tracing 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "pin-project-lite 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            },
+            {
+                "id": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "unicode_xid",
+                        "pkg": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "proc-macro"
+                ]
+            },
+            {
+                "id": "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "default",
+                    "proc-macro"
+                ]
+            },
+            {
+                "id": "syn 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "unicode_xid",
+                        "pkg": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "clone-impls",
+                    "extra-traits",
+                    "full",
+                    "parsing",
+                    "printing",
+                    "proc-macro",
+                    "quote",
+                    "visit",
+                    "visit-mut"
+                ]
+            },
+            {
+                "id": "tracing 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                "dependencies": [
+                    "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "pin-project-lite 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "tracing-attributes 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                    "tracing-core 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)"
+                ],
+                "deps": [
+                    {
+                        "name": "cfg_if",
+                        "pkg": "cfg-if 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "pin_project_lite",
+                        "pkg": "pin-project-lite 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "tracing_attributes",
+                        "pkg": "tracing-attributes 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "tracing_core",
+                        "pkg": "tracing-core 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "alloc",
+                    "attributes",
+                    "default",
+                    "std",
+                    "tracing-attributes"
+                ]
+            },
+            {
+                "id": "tracing-attributes 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                "dependencies": [
+                    "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                    "syn 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "proc_macro2",
+                        "pkg": "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "quote",
+                        "pkg": "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    },
+                    {
+                        "name": "syn",
+                        "pkg": "syn 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "tracing-core 0.2.0 (git+https://github.com/tokio-rs/tracing.git?rev=1e09e50e8d15580b5929adbade9c782a6833e4a0#1e09e50e8d15580b5929adbade9c782a6833e4a0)",
+                "dependencies": [
+                    "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "lazy_static",
+                        "pkg": "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": [
+                    "alloc",
+                    "lazy_static",
+                    "std"
+                ]
+            },
+            {
+                "id": "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default"
+                ]
+            }
+        ],
+        "root": "git-repos 0.1.0 (path+file://{TEMP_DIR}/git_repos)"
+    },
+    "target_directory": "{TEMP_DIR}/git_repos/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/git_repos",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.lock
new file mode 100644
index 0000000..b93c068
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.lock
@@ -0,0 +1,25 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"
+
+[[package]]
+name = "multi_cfg_dep"
+version = "0.1.0"
+dependencies = [
+ "cpufeatures",
+]
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.toml
new file mode 100644
index 0000000..f3175ee
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "multi_cfg_dep"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cpufeatures = "=0.2.1"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/metadata.json
new file mode 100644
index 0000000..072e630
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/multi_cfg_dep/metadata.json
@@ -0,0 +1,340 @@
+{
+    "packages": [
+        {
+            "name": "cpufeatures",
+            "version": "0.2.1",
+            "id": "cpufeatures 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Lightweight and efficient no-std compatible alternative to the\nis_x86_feature_detected! macro\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.101",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "aarch64-apple-darwin",
+                    "registry": null
+                },
+                {
+                    "name": "libc",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^0.2.101",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))",
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "cpufeatures",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cpufeatures-0.2.1/src/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "x86",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cpufeatures-0.2.1/tests/x86.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "aarch64",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cpufeatures-0.2.1/tests/aarch64.rs",
+                    "edition": "2018",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/cpufeatures-0.2.1/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [
+                "RustCrypto Developers"
+            ],
+            "categories": [
+                "no-std"
+            ],
+            "keywords": [
+                "cpuid",
+                "target-feature"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/RustCrypto/utils",
+            "homepage": null,
+            "documentation": "https://docs.rs/cpufeatures",
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "libc",
+            "version": "0.2.117",
+            "id": "libc 0.2.117 (registry+https://github.com/rust-lang/crates.io-index)",
+            "license": "MIT OR Apache-2.0",
+            "license_file": null,
+            "description": "Raw FFI bindings to platform libraries like libc.\n",
+            "source": "registry+https://github.com/rust-lang/crates.io-index",
+            "dependencies": [
+                {
+                    "name": "rustc-std-workspace-core",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": true,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "libc",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.117/src/lib.rs",
+                    "edition": "2015",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "test"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "const_fn",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.117/tests/const_fn.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": true
+                },
+                {
+                    "kind": [
+                        "custom-build"
+                    ],
+                    "crate_types": [
+                        "bin"
+                    ],
+                    "name": "build-script-build",
+                    "src_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.117/build.rs",
+                    "edition": "2015",
+                    "doc": false,
+                    "doctest": false,
+                    "test": false
+                }
+            ],
+            "features": {
+                "align": [],
+                "const-extern-fn": [],
+                "default": [
+                    "std"
+                ],
+                "extra_traits": [],
+                "rustc-dep-of-std": [
+                    "align",
+                    "rustc-std-workspace-core"
+                ],
+                "std": [],
+                "use_std": [
+                    "std"
+                ]
+            },
+            "manifest_path": "{CARGO_HOME}/registry/src/github.com-1ecc6299db9ec823/libc-0.2.117/Cargo.toml",
+            "metadata": {
+                "docs": {
+                    "rs": {
+                        "features": [
+                            "const-extern-fn",
+                            "extra_traits"
+                        ]
+                    }
+                }
+            },
+            "publish": null,
+            "authors": [
+                "The Rust Project Developers"
+            ],
+            "categories": [
+                "external-ffi-bindings",
+                "no-std",
+                "os"
+            ],
+            "keywords": [
+                "libc",
+                "ffi",
+                "bindings",
+                "operating",
+                "system"
+            ],
+            "readme": "README.md",
+            "repository": "https://github.com/rust-lang/libc",
+            "homepage": "https://github.com/rust-lang/libc",
+            "documentation": "https://docs.rs/libc/",
+            "edition": "2015",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        },
+        {
+            "name": "multi_cfg_dep",
+            "version": "0.1.0",
+            "id": "multi_cfg_dep 0.1.0 (path+file://{TEMP_DIR}/multi_cfg_dep)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [
+                {
+                    "name": "cpufeatures",
+                    "source": "registry+https://github.com/rust-lang/crates.io-index",
+                    "req": "=0.2.1",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false,
+                    "uses_default_features": true,
+                    "features": [],
+                    "target": null,
+                    "registry": null
+                }
+            ],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "multi_cfg_dep",
+                    "src_path": "{TEMP_DIR}/multi_cfg_dep/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/multi_cfg_dep/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "multi_cfg_dep 0.1.0 (path+file://{TEMP_DIR}/multi_cfg_dep)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "cpufeatures 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [
+                    "libc 0.2.117 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "libc",
+                        "pkg": "libc 0.2.117 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": "aarch64-apple-darwin"
+                            },
+                            {
+                                "kind": null,
+                                "target": "cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))"
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            },
+            {
+                "id": "libc 0.2.117 (registry+https://github.com/rust-lang/crates.io-index)",
+                "dependencies": [],
+                "deps": [],
+                "features": [
+                    "default",
+                    "std"
+                ]
+            },
+            {
+                "id": "multi_cfg_dep 0.1.0 (path+file://{TEMP_DIR}/multi_cfg_dep)",
+                "dependencies": [
+                    "cpufeatures 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)"
+                ],
+                "deps": [
+                    {
+                        "name": "cpufeatures",
+                        "pkg": "cpufeatures 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+                        "dep_kinds": [
+                            {
+                                "kind": null,
+                                "target": null
+                            }
+                        ]
+                    }
+                ],
+                "features": []
+            }
+        ],
+        "root": "multi_cfg_dep 0.1.0 (path+file://{TEMP_DIR}/multi_cfg_dep)"
+    },
+    "target_directory": "{TEMP_DIR}/multi_cfg_dep/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/multi_cfg_dep",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.lock b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.lock
new file mode 100644
index 0000000..6fb64e0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "no-deps"
+version = "0.1.0"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.toml b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.toml
new file mode 100644
index 0000000..8b7c20a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "no-deps"
+version = "0.1.0"
+edition = "2018"
+
+# Required to satisfy cargo but no `lib.rs` is expected to
+# exist within test data.
+[lib]
+path = "lib.rs"
diff --git a/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/metadata.json b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/metadata.json
new file mode 100644
index 0000000..1ea9494
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/metadata/no_deps/metadata.json
@@ -0,0 +1,63 @@
+{
+    "packages": [
+        {
+            "name": "no-deps",
+            "version": "0.1.0",
+            "id": "no-deps 0.1.0 (path+file://{TEMP_DIR}/no_deps)",
+            "license": null,
+            "license_file": null,
+            "description": null,
+            "source": null,
+            "dependencies": [],
+            "targets": [
+                {
+                    "kind": [
+                        "lib"
+                    ],
+                    "crate_types": [
+                        "lib"
+                    ],
+                    "name": "no-deps",
+                    "src_path": "{TEMP_DIR}/no_deps/lib.rs",
+                    "edition": "2018",
+                    "doc": true,
+                    "doctest": true,
+                    "test": true
+                }
+            ],
+            "features": {},
+            "manifest_path": "{TEMP_DIR}/no_deps/Cargo.toml",
+            "metadata": null,
+            "publish": null,
+            "authors": [],
+            "categories": [],
+            "keywords": [],
+            "readme": null,
+            "repository": null,
+            "homepage": null,
+            "documentation": null,
+            "edition": "2018",
+            "links": null,
+            "default_run": null,
+            "rust_version": null
+        }
+    ],
+    "workspace_members": [
+        "no-deps 0.1.0 (path+file://{TEMP_DIR}/no_deps)"
+    ],
+    "resolve": {
+        "nodes": [
+            {
+                "id": "no-deps 0.1.0 (path+file://{TEMP_DIR}/no_deps)",
+                "dependencies": [],
+                "deps": [],
+                "features": []
+            }
+        ],
+        "root": "no-deps 0.1.0 (path+file://{TEMP_DIR}/no_deps)"
+    },
+    "target_directory": "{TEMP_DIR}/no_deps/target",
+    "version": 1,
+    "workspace_root": "{TEMP_DIR}/no_deps",
+    "metadata": null
+}
diff --git a/third_party/rules_rust/crate_universe/test_data/private/BUILD.bazel b/third_party/rules_rust/crate_universe/test_data/private/BUILD.bazel
new file mode 100644
index 0000000..e0a9bbe
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/private/BUILD.bazel
@@ -0,0 +1,14 @@
+load("@rules_python//python:defs.bzl", "py_binary")
+
+py_binary(
+    name = "metadata_generator",
+    srcs = ["metadata_generator.py"],
+    data = [
+        "@rules_rust//rust/toolchain:current_exec_cargo_files",
+        "@rules_rust//rust/toolchain:current_exec_rustc_files",
+    ],
+    env = {
+        "CARGO": "$(rootpath @rules_rust//rust/toolchain:current_exec_cargo_files)",
+        "RUSTC": "$(rootpath @rules_rust//rust/toolchain:current_exec_rustc_files)",
+    },
+)
diff --git a/third_party/rules_rust/crate_universe/test_data/private/metadata_generator.py b/third_party/rules_rust/crate_universe/test_data/private/metadata_generator.py
new file mode 100755
index 0000000..806caf0
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/test_data/private/metadata_generator.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+from typing import List
+import json
+import os
+import shutil
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+def run_subprocess(command: List[str]) -> subprocess.CompletedProcess[str]:
+    proc = subprocess.run(command, capture_output=True)
+
+    if proc.returncode:
+        print("Subcommand exited with error", proc.returncode, file=sys.stderr)
+        print("Args:", proc.args, file=sys.stderr)
+        print("stderr:", proc.stderr.decode("utf-8"), file=sys.stderr)
+        print("stdout:", proc.stdout.decode("utf-8"), file=sys.stderr)
+        exit(proc.returncode)
+
+    return proc
+
+
+if __name__ == "__main__":
+
+    workspace_root = Path(
+        os.environ.get("BUILD_WORKSPACE_DIRECTORY",
+                       str(Path(__file__).parent.parent.parent.parent.parent)))
+    metadata_dir = workspace_root / "crate_universe/test_data/metadata"
+    cargo = os.getenv("CARGO", "cargo")
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        temp_dir_path.mkdir(parents=True, exist_ok=True)
+
+        for test_dir in metadata_dir.iterdir():
+
+            # Check to see if the directory contains a Cargo manifest
+            real_manifest = test_dir / "Cargo.toml"
+            if not real_manifest.exists():
+                continue
+
+            # Copy the test directory into a temp directory (and out from under a Cargo workspace)
+            manifest_dir = temp_dir_path / test_dir.name
+            # manifest_dir.mkdir(parents=True, exist_ok=True)
+            shutil.copytree(test_dir, manifest_dir)
+
+            manifest = manifest_dir / "Cargo.toml"
+
+            # Generate Lockfile
+            proc = run_subprocess([cargo, "generate-lockfile", "--manifest-path", str(manifest)])
+            lockfile = manifest_dir / "Cargo.lock"
+            if not lockfile.exists():
+                print("Faield to generate lockfile")
+                print("Args:", proc.args, file=sys.stderr)
+                print("stderr:", proc.stderr.decode("utf-8"), file=sys.stderr)
+                print("stdout:", proc.stdout.decode("utf-8"), file=sys.stderr)
+                exit(1)
+
+            shutil.copy2(str(lockfile), str(test_dir / "Cargo.lock"))
+
+            # Generate metadata
+            proc = subprocess.run(
+                [cargo, "metadata", "--format-version", "1", "--manifest-path", str(manifest)],
+                capture_output=True)
+
+            if proc.returncode:
+                print("Subcommand exited with error", proc.returncode, file=sys.stderr)
+                print("Args:", proc.args, file=sys.stderr)
+                print("stderr:", proc.stderr.decode("utf-8"), file=sys.stderr)
+                print("stdout:", proc.stdout.decode("utf-8"), file=sys.stderr)
+                exit(proc.returncode)
+
+            cargo_home = os.environ.get("CARGO_HOME", str(Path.home() / ".cargo"))
+
+            # Replace the temporary directory so package IDs are predictable
+            metadata_text = proc.stdout.decode("utf-8")
+            metadata_text = metadata_text.replace(temp_dir, "{TEMP_DIR}")
+            metadata_text = metadata_text.replace(cargo_home, "{CARGO_HOME}")
+
+            # Write metadata to disk
+            metadata = json.loads(metadata_text)
+            output = test_dir / "metadata.json"
+            output.write_text(json.dumps(metadata, indent=4) + "\n")
diff --git a/third_party/rules_rust/crate_universe/tools/BUILD.bazel b/third_party/rules_rust/crate_universe/tools/BUILD.bazel
new file mode 100644
index 0000000..d465c4d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/BUILD.bazel
@@ -0,0 +1,8 @@
+filegroup(
+    name = "distro",
+    srcs = [
+        "//crate_universe/tools/cross_installer:distro",
+        "//crate_universe/tools/urls_generator:distro",
+    ],
+    visibility = ["//crate_universe:__subpackages__"],
+)
diff --git a/third_party/rules_rust/crate_universe/tools/cross_installer/BUILD.bazel b/third_party/rules_rust/crate_universe/tools/cross_installer/BUILD.bazel
new file mode 100644
index 0000000..46aa087
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/cross_installer/BUILD.bazel
@@ -0,0 +1,37 @@
+load("@crate_index//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+load(":cross_installer_deps.bzl", "cross_binary")
+
+exports_files(
+    ["Cargo.toml"],
+    visibility = ["//visibility:public"],
+)
+
+rust_binary(
+    name = "cross_installer",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    data = [
+        "Cross.toml",
+        ":cross",
+        "@rules_rust//rust/toolchain:current_exec_cargo_files",
+    ],
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    rustc_env = {
+        "CARGO": "$(rootpath @rules_rust//rust/toolchain:current_exec_cargo_files)",
+        "CROSS_BIN": "$(rootpath :cross)",
+        "CROSS_CONFIG": "$(rootpath :Cross.toml)",
+    },
+    deps = all_crate_deps(normal = True),
+)
+
+cross_binary(name = "cross")
+
+filegroup(
+    name = "distro",
+    srcs = [
+        "BUILD.bazel",
+        "Cargo.toml",
+    ],
+    visibility = ["//crate_universe/tools:__pkg__"],
+)
diff --git a/third_party/rules_rust/crate_universe/tools/cross_installer/Cargo.toml b/third_party/rules_rust/crate_universe/tools/cross_installer/Cargo.toml
new file mode 100644
index 0000000..581ac5d
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/cross_installer/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "cross_installer"
+version = "0.1.0"
+edition = "2018"
+
+[[bin]]
+name = "cross_installer"
+path = "src/main.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "3.0.0", features = ["derive"] }
diff --git a/third_party/rules_rust/crate_universe/tools/cross_installer/Cross.toml b/third_party/rules_rust/crate_universe/tools/cross_installer/Cross.toml
new file mode 100644
index 0000000..9a5cdf7
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/cross_installer/Cross.toml
@@ -0,0 +1,26 @@
+# Darwin targets build on the host
+# https://github.com/rust-embedded/cross/issues/223
+# [target.aarch64-apple-darwin]
+# image = "rustembedded/cross:aarch64-apple-darwin"
+
+[target.aarch64-unknown-linux-gnu]
+image = "rustembedded/cross:aarch64-unknown-linux-gnu@sha256:f0695f83156b2bfd3f946637852779207ff247ef60912aa74c2d27006fdf3e60"
+
+# Darwin targets build on the host
+# https://github.com/rust-embedded/cross/issues/223
+# [target.x86_64-apple-darwin]
+# image = "rustembedded/cross:x86_64-apple-darwin"
+
+[target.x86_64-pc-windows-gnu]
+image = "rustembedded/cross:x86_64-pc-windows-gnu@sha256:14d1808255d9e45fb99ef175d75820c3f2194c683df7487a1687d569876d585c"
+
+# Windows MSVC targets build on the host
+# https://github.com/rust-embedded/cross/issues/487
+# [target.x86_64-pc-windows-msvc]
+# image = "rustembedded/cross:x86_64-pc-windows-msvc"
+
+[target.x86_64-unknown-linux-gnu]
+image = "rustembedded/cross:x86_64-unknown-linux-gnu@sha256:f279cf1a8aa8b85717cd53d48bcb2f82e01bde6a47c8c469ebf9ad10415bb2be"
+
+[target.x86_64-unknown-linux-musl]
+image = "rustembedded/cross:x86_64-unknown-linux-musl@sha256:156c441c6b4da1d68599b9d88b4737cf05b7f1bd450a0f6b0a514892e008e373"
diff --git a/third_party/rules_rust/crate_universe/tools/cross_installer/cross_installer_deps.bzl b/third_party/rules_rust/crate_universe/tools/cross_installer/cross_installer_deps.bzl
new file mode 100644
index 0000000..9ad62eb
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/cross_installer/cross_installer_deps.bzl
@@ -0,0 +1,50 @@
+"""Dependencies needed for the cross-installer tool"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+def cross_installer_deps():
+    version = "0.2.1"
+
+    components = {
+        "x86_64-apple-darwin": "589da89453291dc26f0b10b521cdadb98376d495645b210574bd9ca4ec8cfa2c",
+        "x86_64-pc-windows-msvc": "3af59ff5a2229f92b54df937c50a9a88c96dffc8ac3dde520a38fdf046d656c4",
+        "x86_64-unknown-linux-gnu": "06dcce3248488e95fbb368d14bef17fa8e77461d5055fbd5193538574820f413",
+    }
+
+    for triple, sha256 in components.items():
+        maybe(
+            http_archive,
+            name = "cross_{}".format(triple),
+            urls = ["https://github.com/rust-embedded/cross/releases/download/v{version}/cross-v{version}-{triple}.tar.gz".format(
+                triple = triple,
+                version = version,
+            )],
+            sha256 = sha256,
+            build_file_content = """exports_files(glob(["**"]), visibility = ["//visibility:public"])""",
+        )
+
+def cross_binary(name = "cross"):
+    native.config_setting(
+        name = "linux",
+        constraint_values = ["@platforms//os:linux"],
+    )
+
+    native.config_setting(
+        name = "macos",
+        constraint_values = ["@platforms//os:macos"],
+    )
+
+    native.config_setting(
+        name = "windows",
+        constraint_values = ["@platforms//os:windows"],
+    )
+
+    native.alias(
+        name = name,
+        actual = select({
+            ":linux": "@cross_x86_64-unknown-linux-gnu//:cross",
+            ":macos": "@cross_x86_64-apple-darwin//:cross",
+            ":windows": "@cross_x86_64-pc-windows-msvc//:cross.exe",
+        }),
+    )
diff --git a/third_party/rules_rust/crate_universe/tools/cross_installer/src/main.rs b/third_party/rules_rust/crate_universe/tools/cross_installer/src/main.rs
new file mode 100644
index 0000000..552ea0b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/cross_installer/src/main.rs
@@ -0,0 +1,99 @@
+//! A utility for cross compiling binaries using Cross
+
+use std::path::{Path, PathBuf};
+use std::process::{self, Command};
+use std::{env, fs};
+
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+struct Options {
+    /// The path to an artifacts directory expecting to contain directories
+    /// named after platform tripes with binaries inside.
+    #[clap(long)]
+    pub output: PathBuf,
+
+    /// A url prefix where the artifacts can be found
+    #[clap(long)]
+    pub target: String,
+}
+
+/// This function is required until an upstream PR lands
+/// https://github.com/rust-embedded/cross/pull/597
+fn prepare_workspace(workspace_root: &Path) {
+    let src = PathBuf::from(env!("CROSS_CONFIG"));
+    let dest = workspace_root.join("Cross.toml");
+    println!("{:?} -> {:?}", src, dest);
+    fs::copy(src, dest).unwrap();
+
+    // Unfortunately, cross runs into issues when cross compiling incramentally.
+    // To avoid this, the workspace must be cleaned
+    let cargo = env::current_dir().unwrap().join(env!("CARGO"));
+    Command::new(cargo)
+        .current_dir(workspace_root)
+        .arg("clean")
+        .status()
+        .unwrap();
+}
+
+/// Execute a build for the provided platform
+fn execute_cross(working_dir: &Path, target_triple: &str) {
+    let cross = env::current_dir().unwrap().join(env!("CROSS_BIN"));
+    let status = Command::new(cross)
+        .current_dir(working_dir)
+        .arg("build")
+        .arg("--release")
+        .arg("--locked")
+        .arg("--bin")
+        .arg("cargo-bazel")
+        .arg(format!("--target={}", target_triple))
+        .status()
+        .unwrap();
+
+    if !status.success() {
+        process::exit(status.code().unwrap_or(1));
+    }
+}
+
+/// Install results to the output directory
+fn install_outputs(working_dir: &Path, triple: &str, output_dir: &Path) {
+    let is_windows_target = triple.contains("windows");
+    let binary_name = if is_windows_target {
+        "cargo-bazel.exe"
+    } else {
+        "cargo-bazel"
+    };
+
+    // Since we always build from the workspace root, and the output
+    // is always expected to be `./target/{triple}`, we build a path
+    // to the expected output and write it.
+    let artifact = working_dir
+        .join("target")
+        .join(triple)
+        .join("release")
+        .join(binary_name);
+
+    let dest = output_dir.join(triple).join(binary_name);
+    fs::create_dir_all(dest.parent().unwrap()).unwrap();
+    fs::rename(artifact, &dest).unwrap();
+    println!("Installed: {}", dest.display());
+}
+
+fn main() {
+    let opt = Options::parse();
+
+    // Locate the workspace root
+    let workspace_root = PathBuf::from(
+        env::var("BUILD_WORKSPACE_DIRECTORY")
+            .expect("cross_installer is designed to run under Bazel"),
+    );
+
+    // Do some setup
+    prepare_workspace(&workspace_root);
+
+    // Build the binary
+    execute_cross(&workspace_root, &opt.target);
+
+    // Install the results
+    install_outputs(&workspace_root, &opt.target, &opt.output);
+}
diff --git a/third_party/rules_rust/crate_universe/tools/urls_generator/BUILD.bazel b/third_party/rules_rust/crate_universe/tools/urls_generator/BUILD.bazel
new file mode 100644
index 0000000..a461e9b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/urls_generator/BUILD.bazel
@@ -0,0 +1,30 @@
+load("@crate_index//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+exports_files(
+    ["Cargo.toml"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "distro",
+    srcs = [
+        "BUILD.bazel",
+        "Cargo.toml",
+    ],
+    visibility = ["//crate_universe/tools:__pkg__"],
+)
+
+rust_binary(
+    name = "urls_generator",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    compile_data = [
+        "//crate_universe/private:urls.bzl",
+    ],
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    rustc_env = {
+        "MODULE_ROOT_PATH": "$(rootpath //crate_universe/private:urls.bzl)",
+    },
+    deps = all_crate_deps(normal = True),
+)
diff --git a/third_party/rules_rust/crate_universe/tools/urls_generator/Cargo.toml b/third_party/rules_rust/crate_universe/tools/urls_generator/Cargo.toml
new file mode 100644
index 0000000..e9cb43b
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/urls_generator/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "urls_generator"
+version = "0.1.0"
+edition = "2018"
+
+[[bin]]
+name = "urls_generator"
+path = "src/main.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = "3.0.0"
+hex = "0.4.3"
+serde_json = "1.0.73"
+sha2 = "0.10.0"
diff --git a/third_party/rules_rust/crate_universe/tools/urls_generator/src/main.rs b/third_party/rules_rust/crate_universe/tools/urls_generator/src/main.rs
new file mode 100644
index 0000000..c595745
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/tools/urls_generator/src/main.rs
@@ -0,0 +1,183 @@
+//! A helper tool for generating urls and sha256 checksums of cargo-bazel binaries and writing them to a module.
+
+use std::collections::HashMap;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::{env, fs};
+
+use clap::Parser;
+use hex::ToHex;
+use sha2::{Digest, Sha256};
+
+#[derive(Parser, Debug)]
+struct Options {
+    /// The path to an artifacts directory expecting to contain directories
+    /// named after platform tripes with binaries inside.
+    #[clap(long)]
+    pub artifacts_dir: PathBuf,
+
+    /// A url prefix where the artifacts can be found
+    #[clap(long)]
+    pub url_prefix: String,
+
+    /// The path to a buildifier binary. If set, it will be ran on the module
+    #[clap(long)]
+    pub buildifier: Option<PathBuf>,
+}
+
+struct Artifact {
+    pub url: String,
+    pub triple: String,
+    pub sha256: String,
+}
+
+fn calculate_sha256(file_path: &Path) -> String {
+    let file = fs::File::open(file_path).unwrap();
+    let mut reader = BufReader::new(file);
+    let mut hasher = Sha256::new();
+
+    loop {
+        let consummed = {
+            let buffer = reader.fill_buf().unwrap();
+            if buffer.is_empty() {
+                break;
+            }
+            hasher.update(buffer);
+            buffer.len()
+        };
+        reader.consume(consummed);
+    }
+
+    let digest = hasher.finalize();
+    digest.encode_hex::<String>()
+}
+
+fn locate_artifacts(artifacts_dir: &Path, url_prefix: &str) -> Vec<Artifact> {
+    let artifact_dirs: Vec<PathBuf> = artifacts_dir
+        .read_dir()
+        .unwrap()
+        .flatten()
+        .filter(|entry| entry.path().is_dir())
+        .map(|entry| entry.path())
+        .collect();
+
+    artifact_dirs
+        .iter()
+        .map(|path| {
+            let triple = path.file_name().unwrap().to_string_lossy();
+            let mut artifacts: Vec<Artifact> = path
+                .read_dir()
+                .unwrap()
+                .flatten()
+                .map(|f_entry| {
+                    let f_path = f_entry.path();
+                    let stem = f_path.file_stem().unwrap().to_string_lossy();
+                    Artifact {
+                        url: format!("{}/{}-{}", url_prefix, stem, triple),
+                        triple: triple.to_string(),
+                        sha256: calculate_sha256(&f_entry.path()),
+                    }
+                })
+                .collect();
+            if artifacts.len() > 1 {
+                panic!("Too many artifacts given for {}", triple)
+            }
+            artifacts.pop().unwrap()
+        })
+        .collect()
+}
+
+const TEMPLATE: &str = r#""""A file containing urls and associated sha256 values for cargo-bazel binaries
+
+This file is auto-generated for each release to match the urls and sha256s of
+the binaries produced for it.
+"""
+
+# Example:
+# {
+#     "x86_64-unknown-linux-gnu": "https://domain.com/downloads/cargo-bazel-x86_64-unknown-linux-gnu",
+#     "x86_64-apple-darwin": "https://domain.com/downloads/cargo-bazel-x86_64-apple-darwin",
+#     "x86_64-pc-windows-msvc": "https://domain.com/downloads/cargo-bazel-x86_64-pc-windows-msvc",
+# }
+CARGO_BAZEL_URLS = {}
+
+# Example:
+# {
+#     "x86_64-unknown-linux-gnu": "1d687fcc860dc8a1aa6198e531f0aee0637ed506d6a412fe2b9884ff5b2b17c0",
+#     "x86_64-apple-darwin": "0363e450125002f581d29cf632cc876225d738cfa433afa85ca557afb671eafa",
+#     "x86_64-pc-windows-msvc": "f5647261d989f63dafb2c3cb8e131b225338a790386c06cf7112e43dd9805882",
+# }
+CARGO_BAZEL_SHA256S = {}
+
+# Example:
+# Label("//crate_universe:cargo_bazel_bin")
+CARGO_BAZEL_LABEL = Label("@cargo_bazel_bootstrap//:binary")
+"#;
+
+fn render_module(artifacts: &[Artifact]) -> String {
+    let urls: HashMap<&String, &String> = artifacts
+        .iter()
+        .map(|artifact| (&artifact.triple, &artifact.url))
+        .collect();
+
+    let sha256s: HashMap<&String, &String> = artifacts
+        .iter()
+        .map(|artifact| (&artifact.triple, &artifact.sha256))
+        .collect();
+
+    TEMPLATE
+        .replace(
+            "CARGO_BAZEL_URLS = {}",
+            &format!(
+                "CARGO_BAZEL_URLS = {}",
+                serde_json::to_string_pretty(&urls).unwrap()
+            ),
+        )
+        .replace(
+            "CARGO_BAZEL_SHA256S = {}",
+            &format!(
+                "CARGO_BAZEL_SHA256S = {}",
+                serde_json::to_string_pretty(&sha256s).unwrap()
+            ),
+        )
+        .replace(
+            "CARGO_BAZEL_LABEL = Label(\"@cargo_bazel_bootstrap//:binary\")",
+            "CARGO_BAZEL_LABEL = Label(\"//crate_universe:cargo_bazel_bin\")",
+        )
+}
+
+fn write_module(content: &str) -> PathBuf {
+    let dest = PathBuf::from(
+        env::var("BUILD_WORKSPACE_DIRECTORY").expect("This binary is required to run under Bazel"),
+    )
+    .join(env!("MODULE_ROOT_PATH"));
+
+    fs::write(&dest, content).unwrap();
+
+    dest
+}
+
+fn run_buildifier(buildifier_path: &Path, module: &Path) {
+    Command::new(buildifier_path)
+        .arg("-lint=fix")
+        .arg("-mode=fix")
+        .arg("-warnings=all")
+        .arg(module)
+        .output()
+        .unwrap();
+}
+
+fn main() {
+    let opt = Options::parse();
+
+    let artifacts = locate_artifacts(&opt.artifacts_dir, &opt.url_prefix);
+
+    let content = render_module(&artifacts);
+
+    let path = write_module(&content);
+
+    if let Some(buildifier_path) = opt.buildifier {
+        run_buildifier(&buildifier_path, &path);
+    }
+}
diff --git a/third_party/rules_rust/crate_universe/version.bzl b/third_party/rules_rust/crate_universe/version.bzl
new file mode 100644
index 0000000..3b46e3a
--- /dev/null
+++ b/third_party/rules_rust/crate_universe/version.bzl
@@ -0,0 +1,3 @@
+""" Version info for the `cargo-bazel` repository """
+
+VERSION = "0.0.28"
diff --git a/third_party/rules_rust/docs/BUILD.bazel b/third_party/rules_rust/docs/BUILD.bazel
new file mode 100644
index 0000000..6c7e39c
--- /dev/null
+++ b/third_party/rules_rust/docs/BUILD.bazel
@@ -0,0 +1,198 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@io_bazel_stardoc//stardoc:stardoc.bzl", "stardoc")
+load("//:page.bzl", "gen_header", "page")
+
+package(default_visibility = ["//visibility:private"])
+
+bzl_library(
+    name = "docs_deps",
+    srcs = [
+        "@bazel_tools//tools:bzl_srcs",
+        "@build_bazel_rules_nodejs//:bzl",
+        "@com_google_protobuf//:bzl_srcs",
+    ],
+    deps = [
+        "@bazel_skylib//lib:paths",
+        "@bazel_skylib//rules:common_settings",
+        "@rules_proto//proto:defs",
+        "@rules_proto//proto:repositories",
+    ],
+)
+
+bzl_library(
+    name = "all_docs",
+    deps = [
+        ":docs_deps",
+        "@rules_rust//:bzl_lib",
+        "@rules_rust//bindgen:bzl_lib",
+        "@rules_rust//cargo:bzl_lib",
+        "@rules_rust//crate_universe:bzl_lib",
+        "@rules_rust//proto:bzl_lib",
+        "@rules_rust//rust:bzl_lib",
+        "@rules_rust//wasm_bindgen:bzl_lib",
+    ],
+)
+
+PAGES = dict([
+    page(
+        name = "cargo",
+        symbols = [
+            "cargo_bootstrap_repository",
+            "cargo_build_script",
+            "cargo_env",
+        ],
+    ),
+    page(
+        name = "defs",
+        symbols = [
+            "rust_binary",
+            "rust_library",
+            "rust_static_library",
+            "rust_shared_library",
+            "rust_proc_macro",
+            "rust_test",
+            "rust_test_suite",
+            "error_format",
+            "extra_rustc_flags",
+            "capture_clippy_output",
+        ],
+    ),
+    page(
+        name = "providers",
+        symbols = [
+            "CrateInfo",
+            "DepInfo",
+            "StdLibInfo",
+        ],
+    ),
+    page(
+        name = "rust_analyzer",
+        header_template = ":rust_analyzer.vm",
+        symbols = [
+            "rust_analyzer",
+            "rust_analyzer_aspect",
+        ],
+    ),
+    page(
+        name = "rust_bindgen",
+        symbols = [
+            "rust_bindgen_library",
+            "rust_bindgen_repositories",
+            "rust_bindgen_toolchain",
+            "rust_bindgen",
+        ],
+    ),
+    page(
+        name = "rust_clippy",
+        header_template = ":rust_clippy.vm",
+        symbols = [
+            "rust_clippy",
+            "rust_clippy_aspect",
+        ],
+    ),
+    page(
+        name = "rust_doc",
+        symbols = [
+            "rust_doc",
+            "rust_doc_test",
+        ],
+    ),
+    page(
+        name = "rust_fmt",
+        header_template = ":rust_fmt.vm",
+        symbols = [
+            "rustfmt_aspect",
+            "rustfmt_test",
+        ],
+    ),
+    page(
+        name = "rust_proto",
+        header_template = ":rust_proto.vm",
+        symbols = [
+            "rust_grpc_library",
+            "rust_proto_library",
+            "rust_proto_repositories",
+            "rust_proto_transitive_repositories",
+            "rust_proto_toolchain",
+        ],
+    ),
+    page(
+        name = "rust_repositories",
+        symbols = [
+            "rules_rust_dependencies",
+            "rust_register_toolchains",
+            "rust_repositories",
+            "rust_repository_set",
+            "rust_stdlib_filegroup",
+            "rust_toolchain_repository_proxy",
+            "rust_toolchain_repository",
+            "rust_toolchain",
+        ],
+    ),
+    page(
+        name = "rust_wasm_bindgen",
+        header_template = ":rust_wasm_bindgen.vm",
+        symbols = [
+            "rust_wasm_bindgen_repositories",
+            "rust_wasm_bindgen_toolchain",
+            "rust_wasm_bindgen",
+        ],
+    ),
+    page(
+        name = "settings",
+        symbols = [
+            "incompatible_flag",
+            "fail_when_enabled",
+        ],
+    ),
+])
+
+# Generate headers for each page
+[gen_header(page = p) for p in PAGES.values()]
+
+[
+    stardoc(
+        name = "%s_md" % k,
+        out = "%s.md" % k,
+        header_template = ":%s_gen_header_vm" % k,
+        input = ":symbols.bzl",
+        symbol_names = PAGES[k].symbols,
+        deps = [":all_docs"],
+    )
+    for k in PAGES.keys()
+]
+
+genrule(
+    name = "flatten_header_vm",
+    outs = ["flatten_header.vm"],
+    cmd = ">$@ echo '# Rust rules\n\n%s\n'" % "\n".join(
+        sorted(["* [{rule}](#{rule})".format(rule = v) for k in PAGES.keys() for v in PAGES[k].symbols]),
+    ),
+    output_to_bindir = True,
+)
+
+stardoc(
+    name = "flatten_md",
+    out = "flatten.md",
+    header_template = ":flatten_header_vm",
+    input = ":symbols.bzl",
+    symbol_names = sorted([symbol for k in PAGES.keys() for symbol in PAGES[k].symbols]),
+    deps = [":all_docs"],
+)
+
+stardoc(
+    name = "crate_universe",
+    out = "crate_universe.md",
+    input = "@rules_rust//crate_universe:defs.bzl",
+    deps = [":all_docs"],
+)
+
+sh_binary(
+    name = "update_docs",
+    srcs = ["update_docs.sh"],
+)
+
+sh_binary(
+    name = "test_docs",
+    srcs = ["test_docs.sh"],
+)
diff --git a/third_party/rules_rust/docs/README.md b/third_party/rules_rust/docs/README.md
new file mode 100644
index 0000000..1efb5d1
--- /dev/null
+++ b/third_party/rules_rust/docs/README.md
@@ -0,0 +1,3 @@
+# [docs](https://bazelbuild.github.io/rules_rust/)
+
+The index.md in this directory is rendered at https://bazelbuild.github.io/rules_rust/ via [github pages](https://help.github.com/articles/configuring-a-publishing-source-for-github-pages/).
diff --git a/third_party/rules_rust/docs/WORKSPACE.bazel b/third_party/rules_rust/docs/WORKSPACE.bazel
new file mode 100644
index 0000000..1c5a736
--- /dev/null
+++ b/third_party/rules_rust/docs/WORKSPACE.bazel
@@ -0,0 +1,47 @@
+workspace(name = "rules_rust_docs")
+
+local_repository(
+    name = "rules_rust",
+    path = "..",
+)
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains(include_rustc_srcs = True)
+
+load("@rules_rust//crate_universe:crates.bzl", "crate_deps_repository")
+
+crate_deps_repository()
+
+load("@rules_rust//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+
+load("@rules_rust//proto:transitive_repositories.bzl", "rust_proto_transitive_repositories")
+
+rust_proto_transitive_repositories()
+
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+
+load("@build_bazel_rules_nodejs//:index.bzl", "node_repositories")
+
+node_repositories()
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "io_bazel_stardoc",
+    sha256 = "c9794dcc8026a30ff67cf7cf91ebe245ca294b20b071845d12c192afe243ad72",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/stardoc/releases/download/0.5.0/stardoc-0.5.0.tar.gz",
+        "https://github.com/bazelbuild/stardoc/releases/download/0.5.0/stardoc-0.5.0.tar.gz",
+    ],
+)
+
+load("@io_bazel_stardoc//:setup.bzl", "stardoc_repositories")
+
+stardoc_repositories()
diff --git a/third_party/rules_rust/docs/cargo.md b/third_party/rules_rust/docs/cargo.md
new file mode 100644
index 0000000..146e9e1
--- /dev/null
+++ b/third_party/rules_rust/docs/cargo.md
@@ -0,0 +1,176 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Cargo
+
+* [cargo_bootstrap_repository](#cargo_bootstrap_repository)
+* [cargo_build_script](#cargo_build_script)
+* [cargo_env](#cargo_env)
+
+<a id="#cargo_bootstrap_repository"></a>
+
+## cargo_bootstrap_repository
+
+<pre>
+cargo_bootstrap_repository(<a href="#cargo_bootstrap_repository-name">name</a>, <a href="#cargo_bootstrap_repository-binary">binary</a>, <a href="#cargo_bootstrap_repository-build_mode">build_mode</a>, <a href="#cargo_bootstrap_repository-cargo_lockfile">cargo_lockfile</a>, <a href="#cargo_bootstrap_repository-cargo_toml">cargo_toml</a>, <a href="#cargo_bootstrap_repository-env">env</a>, <a href="#cargo_bootstrap_repository-env_label">env_label</a>,
+                           <a href="#cargo_bootstrap_repository-iso_date">iso_date</a>, <a href="#cargo_bootstrap_repository-repo_mapping">repo_mapping</a>, <a href="#cargo_bootstrap_repository-rust_toolchain_cargo_template">rust_toolchain_cargo_template</a>,
+                           <a href="#cargo_bootstrap_repository-rust_toolchain_repository_template">rust_toolchain_repository_template</a>, <a href="#cargo_bootstrap_repository-rust_toolchain_rustc_template">rust_toolchain_rustc_template</a>, <a href="#cargo_bootstrap_repository-srcs">srcs</a>,
+                           <a href="#cargo_bootstrap_repository-timeout">timeout</a>, <a href="#cargo_bootstrap_repository-version">version</a>)
+</pre>
+
+A rule for bootstrapping a Rust binary using [Cargo](https://doc.rust-lang.org/cargo/)
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="cargo_bootstrap_repository-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="cargo_bootstrap_repository-binary"></a>binary |  The binary to build (the <code>--bin</code> parameter for Cargo). If left empty, the repository name will be used.   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-build_mode"></a>build_mode |  The build mode the binary should be built with   | String | optional | "release" |
+| <a id="cargo_bootstrap_repository-cargo_lockfile"></a>cargo_lockfile |  The lockfile of the crate_universe resolver   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="cargo_bootstrap_repository-cargo_toml"></a>cargo_toml |  The path of the crate_universe resolver manifest (<code>Cargo.toml</code> file)   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="cargo_bootstrap_repository-env"></a>env |  A mapping of platform triple to a set of environment variables. See [cargo_env](#cargo_env) for usage details. Additionally, the platform triple <code>*</code> applies to all platforms.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="cargo_bootstrap_repository-env_label"></a>env_label |  A mapping of platform triple to a set of environment variables. This attribute differs from <code>env</code> in that all variables passed here must be fully qualified labels of files. See [cargo_env](#cargo_env) for usage details. Additionally, the platform triple <code>*</code> applies to all platforms.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="cargo_bootstrap_repository-iso_date"></a>iso_date |  The iso_date of cargo binary the resolver should use. Note: This can only be set if <code>version</code> is <code>beta</code> or <code>nightly</code>   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="cargo_bootstrap_repository-rust_toolchain_cargo_template"></a>rust_toolchain_cargo_template |  The template to use for finding the host <code>cargo</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), and <code>{tool}</code> (eg. 'rustc.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="cargo_bootstrap_repository-rust_toolchain_repository_template"></a>rust_toolchain_repository_template |  **Deprecated**: Please use <code>rust_toolchain_cargo_template</code> and <code>rust_toolchain_rustc_template</code>   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-rust_toolchain_rustc_template"></a>rust_toolchain_rustc_template |  The template to use for finding the host <code>rustc</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), and <code>{tool}</code> (eg. 'rustc.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="cargo_bootstrap_repository-srcs"></a>srcs |  Souce files of the crate to build. Passing source files here can be used to trigger rebuilds when changes are made   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="cargo_bootstrap_repository-timeout"></a>timeout |  Maximum duration of the Cargo build command in seconds   | Integer | optional | 600 |
+| <a id="cargo_bootstrap_repository-version"></a>version |  The version of cargo the resolver should use   | String | optional | "1.59.0" |
+
+
+<a id="#cargo_build_script"></a>
+
+## cargo_build_script
+
+<pre>
+cargo_build_script(<a href="#cargo_build_script-name">name</a>, <a href="#cargo_build_script-crate_features">crate_features</a>, <a href="#cargo_build_script-version">version</a>, <a href="#cargo_build_script-deps">deps</a>, <a href="#cargo_build_script-build_script_env">build_script_env</a>, <a href="#cargo_build_script-data">data</a>, <a href="#cargo_build_script-tools">tools</a>, <a href="#cargo_build_script-links">links</a>,
+                   <a href="#cargo_build_script-rustc_env">rustc_env</a>, <a href="#cargo_build_script-rustc_flags">rustc_flags</a>, <a href="#cargo_build_script-visibility">visibility</a>, <a href="#cargo_build_script-tags">tags</a>, <a href="#cargo_build_script-kwargs">kwargs</a>)
+</pre>
+
+Compile and execute a rust build script to generate build attributes
+
+This rules take the same arguments as rust_binary.
+
+Example:
+
+Suppose you have a crate with a cargo build script `build.rs`:
+
+```output
+[workspace]/
+    hello_lib/
+        BUILD
+        build.rs
+        src/
+            lib.rs
+```
+
+Then you want to use the build script in the following:
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
+load("@rules_rust//cargo:cargo_build_script.bzl", "cargo_build_script")
+
+# This will run the build script from the root of the workspace, and
+# collect the outputs.
+cargo_build_script(
+    name = "build_script",
+    srcs = ["build.rs"],
+    # Optional environment variables passed during build.rs compilation
+    rustc_env = {
+       "CARGO_PKG_VERSION": "0.1.2",
+    },
+    # Optional environment variables passed during build.rs execution.
+    # Note that as the build script's working directory is not execroot,
+    # execpath/location will return an absolute path, instead of a relative
+    # one.
+    build_script_env = {
+        "SOME_TOOL_OR_FILE": "$(execpath @tool//:binary)"
+    }
+    # Optional data/tool dependencies
+    data = ["@tool//:binary"],
+)
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/lib.rs",
+    ],
+    deps = [":build_script"],
+)
+```
+
+The `hello_lib` target will be build with the flags and the environment variables declared by the     build script in addition to the file generated by it.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="cargo_build_script-name"></a>name |  The name for the underlying rule. This should be the name of the package being compiled, optionally with a suffix of _build_script.   |  none |
+| <a id="cargo_build_script-crate_features"></a>crate_features |  A list of features to enable for the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-version"></a>version |  The semantic version (semver) of the crate.   |  <code>None</code> |
+| <a id="cargo_build_script-deps"></a>deps |  The dependencies of the crate.   |  <code>[]</code> |
+| <a id="cargo_build_script-build_script_env"></a>build_script_env |  Environment variables for build scripts.   |  <code>{}</code> |
+| <a id="cargo_build_script-data"></a>data |  Files needed by the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-tools"></a>tools |  Tools (executables) needed by the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-links"></a>links |  Name of the native library this crate links against.   |  <code>None</code> |
+| <a id="cargo_build_script-rustc_env"></a>rustc_env |  Environment variables to set in rustc when compiling the build script.   |  <code>{}</code> |
+| <a id="cargo_build_script-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.   |  <code>[]</code> |
+| <a id="cargo_build_script-visibility"></a>visibility |  Visibility to apply to the generated build script output.   |  <code>None</code> |
+| <a id="cargo_build_script-tags"></a>tags |  (list of str, optional): Tags to apply to the generated build script output.   |  <code>None</code> |
+| <a id="cargo_build_script-kwargs"></a>kwargs |  Forwards to the underlying <code>rust_binary</code> rule.   |  none |
+
+
+<a id="#cargo_env"></a>
+
+## cargo_env
+
+<pre>
+cargo_env(<a href="#cargo_env-env">env</a>)
+</pre>
+
+A helper for generating platform specific environment variables
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_common")
+load("@rules_rust//cargo:defs.bzl", "cargo_bootstrap_repository", "cargo_env")
+
+cargo_bootstrap_repository(
+    name = "bootstrapped_bin",
+    cargo_lockfile = "//:Cargo.lock",
+    cargo_toml = "//:Cargo.toml",
+    srcs = ["//:resolver_srcs"],
+    version = rust_common.default_version,
+    binary = "my-crate-binary",
+    env = {
+        "x86_64-unknown-linux-gnu": cargo_env({
+            "FOO": "BAR",
+        }),
+    },
+    env_label = {
+        "aarch64-unknown-linux-musl": cargo_env({
+            "DOC": "//:README.md",
+        }),
+    }
+)
+```
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="cargo_env-env"></a>env |  A map of environment variables   |  none |
+
+**RETURNS**
+
+str: A json encoded string of the environment variables
+
+
diff --git a/third_party/rules_rust/docs/crate_universe.md b/third_party/rules_rust/docs/crate_universe.md
new file mode 100644
index 0000000..4dfcd5d
--- /dev/null
+++ b/third_party/rules_rust/docs/crate_universe.md
@@ -0,0 +1,405 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+
+# Crate Universe
+
+Crate Universe is a set of Bazel rule for generating Rust targets using Cargo.
+
+## Experimental
+
+`crate_universe` is experimental, and may have breaking API changes at any time. These instructions may also change without notice.
+
+## Rules
+
+- [crates_repository](#crates_repository)
+- [crates_vendor](#crates_vendor)
+- [crate.spec](#cratespec)
+- [crate.workspace_member](#crateworkspace_member)
+- [crate.annotation](#crateannotation)
+- [render_config](#render_config)
+- [splicing_config](#splicing_config)
+
+## `crates_repository` Workflows
+
+The [`crates_repository`](#crates_repository) rule (the primary repository rule of `cargo-bazel`) supports a number of different ways users
+can express and organize their dependencies. The most common are listed below though there are more to be found in
+the [./examples/crate_universe](https://github.com/bazelbuild/rules_rust/tree/main/examples/crate_universe) directory.
+
+### Cargo Workspaces
+
+One of the simpler ways to wire up dependencies would be to first structure your project into a [Cargo workspace][cw].
+The `crates_repository` rule can ingest a the root `Cargo.toml` file and generate dependencies from there.
+
+```python
+load("@rules_rust//crate_universe:defs.bzl", "crate", "crates_repository")
+
+crates_repository(
+    name = "crate_index",
+    lockfile = "//:Cargo.Bazel.lock",
+    manifests = ["//:Cargo.toml"],
+)
+
+load("@crate_index//:defs.bzl", "crate_repositories")
+
+crate_repositories()
+```
+
+The generated `crates_repository` contains helper macros which make collecting dependencies for Bazel targets simpler.
+Notably, the `all_crate_deps` and `aliases` macros commonly allow the `Cargo.toml` files to be the single source of
+truth for dependencies. Since these macros come from the generated repository, the dependencies and alias definitions
+they return will automatically update BUILD targets.
+
+```python
+load("@crate_index//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "lib",
+    aliases = aliases(),
+    deps = all_crate_deps(
+        normal = True,
+    ),
+    proc_macro_deps = all_crate_deps(
+        proc_macro = True,
+    ),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":lib",
+    aliases = aliases(
+        normal_dev = True,
+        proc_macro_dev = True,
+    ),
+    deps = all_crate_deps(
+        normal_dev = True,
+    ),
+    proc_macro_deps = all_crate_deps(
+        proc_macro_dev = True,
+    ),
+)
+```
+
+### Direct Packages
+
+In cases where Rust targets have heavy interractions with other Bazel targests ([Cc][cc], [Proto][proto], etc.),
+maintaining `Cargo.toml` files may have deminishing returns as things like [rust-analyzer][ra] begin to be confused
+about missing targets or environment variables defined only in Bazel. In workspaces like this, it may be desirable
+to have a "Cargo free" setup. `crates_repository` supports this through the `packages` attribute.
+
+```python
+load("@cargo_bazel//:defs.bzl", "crate", "crates_repository", "render_config")
+
+crates_repository(
+    name = "crate_index",
+    lockfile = "//:Cargo.Bazel.lock",
+    packages = {
+        "async-trait": crate.spec(
+            version = "0.1.51",
+        ),
+        "mockall": crate.spec(
+            version = "0.10.2",
+        ),
+        "tokio": crate.spec(
+            version = "1.12.0",
+        ),
+    },
+    # Setting the default package name to `""` forces the use of the macros defined in this repository
+    # to always use the root package when looking for dependencies or aliases. This should be considered
+    # optional as the repository also exposes alises for easy access to all dependencies.
+    render_config = render_config(
+        default_package_name = ""
+    ),
+)
+
+load("@crate_index//:defs.bzl", "crate_repositories")
+
+crate_repositories()
+```
+
+Consuming dependencies may be more ergonomic in this case through the aliases defined in the new repository.
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "lib",
+    deps = [
+        "@crate_index//:tokio",
+    ],
+    proc_macro_deps = [
+        "@crate_index//:async-trait",
+    ],
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":lib",
+    deps = [
+        "@crate_index//:mockall",
+    ],
+)
+```
+
+[cw]: https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html
+[cc]: https://docs.bazel.build/versions/main/be/c-cpp.html
+[proto]: https://rules-proto-grpc.com/en/latest/lang/rust.html
+[ra]: https://rust-analyzer.github.io/
+
+
+<a id="#crates_repository"></a>
+
+## crates_repository
+
+<pre>
+crates_repository(<a href="#crates_repository-name">name</a>, <a href="#crates_repository-annotations">annotations</a>, <a href="#crates_repository-cargo_config">cargo_config</a>, <a href="#crates_repository-extra_workspace_member_url_template">extra_workspace_member_url_template</a>,
+                  <a href="#crates_repository-extra_workspace_members">extra_workspace_members</a>, <a href="#crates_repository-generate_build_scripts">generate_build_scripts</a>, <a href="#crates_repository-generator">generator</a>, <a href="#crates_repository-generator_sha256s">generator_sha256s</a>,
+                  <a href="#crates_repository-generator_urls">generator_urls</a>, <a href="#crates_repository-isolated">isolated</a>, <a href="#crates_repository-lockfile">lockfile</a>, <a href="#crates_repository-lockfile_kind">lockfile_kind</a>, <a href="#crates_repository-manifests">manifests</a>, <a href="#crates_repository-packages">packages</a>, <a href="#crates_repository-quiet">quiet</a>,
+                  <a href="#crates_repository-render_config">render_config</a>, <a href="#crates_repository-repo_mapping">repo_mapping</a>, <a href="#crates_repository-rust_toolchain_cargo_template">rust_toolchain_cargo_template</a>,
+                  <a href="#crates_repository-rust_toolchain_rustc_template">rust_toolchain_rustc_template</a>, <a href="#crates_repository-rust_version">rust_version</a>, <a href="#crates_repository-splicing_config">splicing_config</a>,
+                  <a href="#crates_repository-supported_platform_triples">supported_platform_triples</a>)
+</pre>
+
+A rule for defining and downloading Rust dependencies (crates).
+
+Environment Variables:
+
+| variable | usage |
+| --- | --- |
+| `CARGO_BAZEL_GENERATOR_SHA256` | The sha256 checksum of the file located at `CARGO_BAZEL_GENERATOR_URL` |
+| `CARGO_BAZEL_GENERATOR_URL` | The URL of a cargo-bazel binary. This variable takes precedence over attributes and can use `file://` for local paths |
+| `CARGO_BAZEL_ISOLATED` | An authorative flag as to whether or not the `CARGO_HOME` environment variable should be isolated from the host configuration |
+| `CARGO_BAZEL_REPIN` | An indicator that the dependencies represented by the rule should be regenerated. `REPIN` may also be used. |
+
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="crates_repository-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="crates_repository-annotations"></a>annotations |  Extra settings to apply to crates. See [crate.annotations](#crateannotations).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> List of strings</a> | optional | {} |
+| <a id="crates_repository-cargo_config"></a>cargo_config |  A [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html) file   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="crates_repository-extra_workspace_member_url_template"></a>extra_workspace_member_url_template |  The registry url to use when fetching extra workspace members   | String | optional | "https://crates.io/api/v1/crates/{name}/{version}/download" |
+| <a id="crates_repository-extra_workspace_members"></a>extra_workspace_members |  Additional crates to download and include as a workspace member. This is unfortunately required in order to add information about "binary-only" crates so that a <code>rust_binary</code> may be generated for it. [rust-lang/cargo#9096](https://github.com/rust-lang/cargo/issues/9096) tracks an RFC which may solve for this.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="crates_repository-generate_build_scripts"></a>generate_build_scripts |  Whether or not to generate [cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default.   | Boolean | optional | True |
+| <a id="crates_repository-generator"></a>generator |  The absolute label of a generator. Eg. <code>@cargo_bazel_bootstrap//:cargo-bazel</code>. This is typically used when bootstrapping   | String | optional | "" |
+| <a id="crates_repository-generator_sha256s"></a>generator_sha256s |  Dictionary of <code>host_triple</code> -&gt; <code>sha256</code> for a <code>cargo-bazel</code> binary.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="crates_repository-generator_urls"></a>generator_urls |  URL template from which to download the <code>cargo-bazel</code> binary. <code>{host_triple}</code> and will be filled in according to the host platform.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="crates_repository-isolated"></a>isolated |  If true, <code>CARGO_HOME</code> will be overwritten to a directory within the generated repository in order to prevent other uses of Cargo from impacting having any effect on the generated targets produced by this rule. For users who either have multiple <code>crate_repository</code> definitions in a WORKSPACE or rapidly re-pin dependencies, setting this to false may improve build times. This variable is also controled by <code>CARGO_BAZEL_ISOLATED</code> environment variable.   | Boolean | optional | True |
+| <a id="crates_repository-lockfile"></a>lockfile |  The path to a file to use for reproducible renderings. Two kinds of lock files are supported, Cargo (<code>Cargo.lock</code> files) and Bazel (custom files generated by this rule, naming is irrelevant). Bazel lockfiles should be the prefered kind as they're desigend with Bazel's notions of reporducibility in mind. Cargo lockfiles can be used in cases where it's intended to be the source of truth, but more work will need to be done to generate BUILD files which are not guaranteed to be determinsitic.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="crates_repository-lockfile_kind"></a>lockfile_kind |  Two different kinds of lockfiles are supported, the custom "Bazel" lockfile, which is generated by this rule, and Cargo lockfiles (<code>Cargo.lock</code>). This attribute allows for explicitly defining the type in cases where it may not be auto-detectable.   | String | optional | "auto" |
+| <a id="crates_repository-manifests"></a>manifests |  A list of Cargo manifests (<code>Cargo.toml</code> files).   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="crates_repository-packages"></a>packages |  A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="crates_repository-quiet"></a>quiet |  If stdout and stderr should not be printed to the terminal.   | Boolean | optional | True |
+| <a id="crates_repository-render_config"></a>render_config |  The configuration flags to use for rendering. Use <code>//crate_universe:defs.bzl\%render_config</code> to generate the value for this field. If unset, the defaults defined there will be used.   | String | optional | "" |
+| <a id="crates_repository-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="crates_repository-rust_toolchain_cargo_template"></a>rust_toolchain_cargo_template |  The template to use for finding the host <code>cargo</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), <code>{cfg}</code> (eg. 'exec'), and <code>{tool}</code> (eg. 'rustc.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="crates_repository-rust_toolchain_rustc_template"></a>rust_toolchain_rustc_template |  The template to use for finding the host <code>rustc</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), <code>{cfg}</code> (eg. 'exec'), and <code>{tool}</code> (eg. 'cargo.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="crates_repository-rust_version"></a>rust_version |  The version of Rust the currently registered toolchain is using. Eg. <code>1.56.0</code>, or <code>nightly-2021-09-08</code>   | String | optional | "1.59.0" |
+| <a id="crates_repository-splicing_config"></a>splicing_config |  The configuration flags to use for splicing Cargo maniests. Use <code>//crate_universe:defs.bzl\%rsplicing_config</code> to generate the value for this field. If unset, the defaults defined there will be used.   | String | optional | "" |
+| <a id="crates_repository-supported_platform_triples"></a>supported_platform_triples |  A set of all platform triples to consider when generating dependencies.   | List of strings | optional | ["i686-apple-darwin", "i686-pc-windows-msvc", "i686-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-linux-android", "i686-unknown-freebsd", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd"] |
+
+
+<a id="#crates_vendor"></a>
+
+## crates_vendor
+
+<pre>
+crates_vendor(<a href="#crates_vendor-name">name</a>, <a href="#crates_vendor-annotations">annotations</a>, <a href="#crates_vendor-buildifier">buildifier</a>, <a href="#crates_vendor-cargo_bazel">cargo_bazel</a>, <a href="#crates_vendor-generate_build_scripts">generate_build_scripts</a>, <a href="#crates_vendor-manifests">manifests</a>, <a href="#crates_vendor-mode">mode</a>,
+              <a href="#crates_vendor-packages">packages</a>, <a href="#crates_vendor-repository_name">repository_name</a>, <a href="#crates_vendor-splicing_config">splicing_config</a>, <a href="#crates_vendor-supported_platform_triples">supported_platform_triples</a>, <a href="#crates_vendor-vendor_path">vendor_path</a>)
+</pre>
+
+A rule for defining Rust dependencies (crates) and writing targets for them to the current workspace
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="crates_vendor-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="crates_vendor-annotations"></a>annotations |  Extra settings to apply to crates. See [crate.annotations](#crateannotations).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> List of strings</a> | optional | {} |
+| <a id="crates_vendor-buildifier"></a>buildifier |  The path to a [buildifier](https://github.com/bazelbuild/buildtools/blob/5.0.1/buildifier/README.md) binary used to format generated BUILD files.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | //crate_universe/private/vendor:buildifier |
+| <a id="crates_vendor-cargo_bazel"></a>cargo_bazel |  The cargo-bazel binary to use for vendoring. If this attribute is not set, then a <code>CARGO_BAZEL_GENERATOR_PATH</code> action env will be used.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | @cargo_bazel_bootstrap//:binary |
+| <a id="crates_vendor-generate_build_scripts"></a>generate_build_scripts |  Whether or not to generate [cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default.   | Boolean | optional | True |
+| <a id="crates_vendor-manifests"></a>manifests |  A list of Cargo manifests (<code>Cargo.toml</code> files).   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="crates_vendor-mode"></a>mode |  Flags determining how crates should be vendored. <code>local</code> is where crate source and BUILD files are written to the repository. <code>remote</code> is where only BUILD files are written and repository rules used to fetch source code.   | String | optional | "remote" |
+| <a id="crates_vendor-packages"></a>packages |  A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="crates_vendor-repository_name"></a>repository_name |  The name of the repository to generate for <code>remote</code> vendor modes. If unset, the label name will be used   | String | optional | "" |
+| <a id="crates_vendor-splicing_config"></a>splicing_config |  The configuration flags to use for splicing Cargo maniests. Use <code>//crate_universe:defs.bzl\%rsplicing_config</code> to generate the value for this field. If unset, the defaults defined there will be used.   | String | optional | "" |
+| <a id="crates_vendor-supported_platform_triples"></a>supported_platform_triples |  A set of all platform triples to consider when generating dependencies.   | List of strings | optional | ["i686-apple-darwin", "i686-pc-windows-msvc", "i686-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-linux-android", "i686-unknown-freebsd", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd"] |
+| <a id="crates_vendor-vendor_path"></a>vendor_path |  The path to a directory to write files into. Absolute paths will be treated as relative to the workspace root   | String | optional | "crates" |
+
+
+<a id="#crate.spec"></a>
+
+## crate.spec
+
+<pre>
+crate.spec(<a href="#crate.spec-package">package</a>, <a href="#crate.spec-version">version</a>, <a href="#crate.spec-default_features">default_features</a>, <a href="#crate.spec-features">features</a>, <a href="#crate.spec-git">git</a>, <a href="#crate.spec-rev">rev</a>)
+</pre>
+
+A constructor for a crate dependency.
+
+See [specifying dependencies][sd] in the Cargo book for more details.
+
+[sd]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="crate.spec-package"></a>package |  The explicit name of the package (used when attempting to alias a crate).   |  <code>None</code> |
+| <a id="crate.spec-version"></a>version |  The exact version of the crate. Cannot be used with <code>git</code>.   |  <code>None</code> |
+| <a id="crate.spec-default_features"></a>default_features |  Maps to the <code>default-features</code> flag.   |  <code>True</code> |
+| <a id="crate.spec-features"></a>features |  A list of features to use for the crate   |  <code>[]</code> |
+| <a id="crate.spec-git"></a>git |  The Git url to use for the crate. Cannot be used with <code>version</code>.   |  <code>None</code> |
+| <a id="crate.spec-rev"></a>rev |  The git revision of the remote crate. Tied with the <code>git</code> param.   |  <code>None</code> |
+
+**RETURNS**
+
+string: A json encoded string of all inputs
+
+
+<a id="#crate.annotation"></a>
+
+## crate.annotation
+
+<pre>
+crate.annotation(<a href="#crate.annotation-version">version</a>, <a href="#crate.annotation-additive_build_file">additive_build_file</a>, <a href="#crate.annotation-additive_build_file_content">additive_build_file_content</a>, <a href="#crate.annotation-build_script_data">build_script_data</a>,
+                 <a href="#crate.annotation-build_script_data_glob">build_script_data_glob</a>, <a href="#crate.annotation-build_script_deps">build_script_deps</a>, <a href="#crate.annotation-build_script_env">build_script_env</a>,
+                 <a href="#crate.annotation-build_script_proc_macro_deps">build_script_proc_macro_deps</a>, <a href="#crate.annotation-build_script_rustc_env">build_script_rustc_env</a>, <a href="#crate.annotation-compile_data">compile_data</a>,
+                 <a href="#crate.annotation-compile_data_glob">compile_data_glob</a>, <a href="#crate.annotation-crate_features">crate_features</a>, <a href="#crate.annotation-data">data</a>, <a href="#crate.annotation-data_glob">data_glob</a>, <a href="#crate.annotation-deps">deps</a>, <a href="#crate.annotation-gen_build_script">gen_build_script</a>,
+                 <a href="#crate.annotation-patch_args">patch_args</a>, <a href="#crate.annotation-patch_tool">patch_tool</a>, <a href="#crate.annotation-patches">patches</a>, <a href="#crate.annotation-proc_macro_deps">proc_macro_deps</a>, <a href="#crate.annotation-rustc_env">rustc_env</a>, <a href="#crate.annotation-rustc_env_files">rustc_env_files</a>,
+                 <a href="#crate.annotation-rustc_flags">rustc_flags</a>, <a href="#crate.annotation-shallow_since">shallow_since</a>)
+</pre>
+
+A collection of extra attributes and settings for a particular crate
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="crate.annotation-version"></a>version |  The version or semver-conditions to match with a crate.   |  <code>"*"</code> |
+| <a id="crate.annotation-additive_build_file"></a>additive_build_file |  A file containing extra contents to write to the bottom of generated BUILD files.   |  <code>None</code> |
+| <a id="crate.annotation-additive_build_file_content"></a>additive_build_file_content |  Extra contents to write to the bottom of generated BUILD files.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_data"></a>build_script_data |  A list of labels to add to a crate's <code>cargo_build_script::data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_data_glob"></a>build_script_data_glob |  A list of glob patterns to add to a crate's <code>cargo_build_script::data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_deps"></a>build_script_deps |  A list of labels to add to a crate's <code>cargo_build_script::deps</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_env"></a>build_script_env |  Additional environment variables to set on a crate's <code>cargo_build_script::env</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_proc_macro_deps"></a>build_script_proc_macro_deps |  A list of labels to add to a crate's <code>cargo_build_script::proc_macro_deps</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-build_script_rustc_env"></a>build_script_rustc_env |  Additional environment variables to set on a crate's <code>cargo_build_script::env</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-compile_data"></a>compile_data |  A list of labels to add to a crate's <code>rust_library::compile_data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-compile_data_glob"></a>compile_data_glob |  A list of glob patterns to add to a crate's <code>rust_library::compile_data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-crate_features"></a>crate_features |  A list of strings to add to a crate's <code>rust_library::crate_features</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-data"></a>data |  A list of labels to add to a crate's <code>rust_library::data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-data_glob"></a>data_glob |  A list of glob patterns to add to a crate's <code>rust_library::data</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-deps"></a>deps |  A list of labels to add to a crate's <code>rust_library::deps</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-gen_build_script"></a>gen_build_script |  An authorative flag to determine whether or not to produce <code>cargo_build_script</code> targets for the current crate.   |  <code>None</code> |
+| <a id="crate.annotation-patch_args"></a>patch_args |  The <code>patch_args</code> attribute of a Bazel repository rule. See [http_archive.patch_args](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_args)   |  <code>None</code> |
+| <a id="crate.annotation-patch_tool"></a>patch_tool |  The <code>patch_tool</code> attribute of a Bazel repository rule. See [http_archive.patch_tool](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patch_tool)   |  <code>None</code> |
+| <a id="crate.annotation-patches"></a>patches |  The <code>patches</code> attribute of a Bazel repository rule. See [http_archive.patches](https://docs.bazel.build/versions/main/repo/http.html#http_archive-patches)   |  <code>None</code> |
+| <a id="crate.annotation-proc_macro_deps"></a>proc_macro_deps |  A list of labels to add to a crate's <code>rust_library::proc_macro_deps</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-rustc_env"></a>rustc_env |  Additional variables to set on a crate's <code>rust_library::rustc_env</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-rustc_env_files"></a>rustc_env_files |  A list of labels to set on a crate's <code>rust_library::rustc_env_files</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-rustc_flags"></a>rustc_flags |  A list of strings to set on a crate's <code>rust_library::rustc_flags</code> attribute.   |  <code>None</code> |
+| <a id="crate.annotation-shallow_since"></a>shallow_since |  An optional timestamp used for crates originating from a git repository instead of a crate registry. This flag optimizes fetching the source code.   |  <code>None</code> |
+
+**RETURNS**
+
+string: A json encoded string containing the specified version and separately all other inputs.
+
+
+<a id="#crate.workspace_member"></a>
+
+## crate.workspace_member
+
+<pre>
+crate.workspace_member(<a href="#crate.workspace_member-version">version</a>, <a href="#crate.workspace_member-sha256">sha256</a>)
+</pre>
+
+Define information for extra workspace members
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="crate.workspace_member-version"></a>version |  The semver of the crate to download. Must be an exact version.   |  none |
+| <a id="crate.workspace_member-sha256"></a>sha256 |  The sha256 checksum of the <code>.crate</code> file.   |  <code>None</code> |
+
+**RETURNS**
+
+string: A json encoded string of all inputs
+
+
+<a id="#render_config"></a>
+
+## render_config
+
+<pre>
+render_config(<a href="#render_config-build_file_template">build_file_template</a>, <a href="#render_config-crate_label_template">crate_label_template</a>, <a href="#render_config-crate_repository_template">crate_repository_template</a>,
+              <a href="#render_config-crates_module_template">crates_module_template</a>, <a href="#render_config-default_package_name">default_package_name</a>, <a href="#render_config-platforms_template">platforms_template</a>, <a href="#render_config-vendor_mode">vendor_mode</a>)
+</pre>
+
+Various settings used to configure rendered outputs
+
+The template parameters each support a select number of format keys. A description of each key
+can be found below where the supported keys for each template can be found in the parameter docs
+
+| key | definition |
+| --- | --- |
+| `name` | The name of the crate. Eg `tokio` |
+| `repository` | The rendered repository name for the crate. Directly relates to `crate_repository_template`. |
+| `triple` | A platform triple. Eg `x86_64-unknown-linux-gnu` |
+| `version` | The crate version. Eg `1.2.3` |
+| `target` | The library or binary target of the crate |
+| `file` | The basename of a file |
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="render_config-build_file_template"></a>build_file_template |  The base template to use for BUILD file names. The available format keys are [<code>{name}</code>, {version}<code>].   |  <code>"//:BUILD.{name}-{version}.bazel"</code> |
+| <a id="render_config-crate_label_template"></a>crate_label_template |  The base template to use for crate labels. The available format keys are [<code>{repository}</code>, <code>{name}</code>, <code>{version}</code>, <code>{target}</code>].   |  <code>"@{repository}__{name}-{version}//:{target}"</code> |
+| <a id="render_config-crate_repository_template"></a>crate_repository_template |  The base template to use for Crate label repository names. The available format keys are [<code>{repository}</code>, <code>{name}</code>, <code>{version}</code>].   |  <code>"{repository}__{name}-{version}"</code> |
+| <a id="render_config-crates_module_template"></a>crates_module_template |  The pattern to use for the <code>defs.bzl</code> and <code>BUILD.bazel</code> file names used for the crates module. The available format keys are [<code>{file}</code>].   |  <code>"//:{file}"</code> |
+| <a id="render_config-default_package_name"></a>default_package_name |  The default package name to in the rendered macros. This affects the auto package detection of things like <code>all_crate_deps</code>.   |  <code>None</code> |
+| <a id="render_config-platforms_template"></a>platforms_template |  The base template to use for platform names. See [platforms documentation](https://docs.bazel.build/versions/main/platforms.html). The available format keys are [<code>{triple}</code>].   |  <code>"@rules_rust//rust/platform:{triple}"</code> |
+| <a id="render_config-vendor_mode"></a>vendor_mode |  An optional configuration for rendirng content to be rendered into repositories.   |  <code>None</code> |
+
+**RETURNS**
+
+string: A json encoded struct to match the Rust `config::RenderConfig` struct
+
+
+<a id="#splicing_config"></a>
+
+## splicing_config
+
+<pre>
+splicing_config(<a href="#splicing_config-resolver_version">resolver_version</a>)
+</pre>
+
+arious settings used to configure Cargo manifest splicing behavior.
+
+[rv]: https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="splicing_config-resolver_version"></a>resolver_version |  The [resolver version][rv] to use in generated Cargo manifests. This flag is **only** used when splicing a manifest from direct package definitions. See <code>crates_repository::packages</code>.   |  <code>"1"</code> |
+
+**RETURNS**
+
+str: A json encoded string of the parameters provided
+
+
diff --git a/third_party/rules_rust/docs/defs.md b/third_party/rules_rust/docs/defs.md
new file mode 100644
index 0000000..6d56201
--- /dev/null
+++ b/third_party/rules_rust/docs/defs.md
@@ -0,0 +1,635 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Defs
+
+* [rust_binary](#rust_binary)
+* [rust_library](#rust_library)
+* [rust_static_library](#rust_static_library)
+* [rust_shared_library](#rust_shared_library)
+* [rust_proc_macro](#rust_proc_macro)
+* [rust_test](#rust_test)
+* [rust_test_suite](#rust_test_suite)
+* [error_format](#error_format)
+* [extra_rustc_flags](#extra_rustc_flags)
+* [capture_clippy_output](#capture_clippy_output)
+
+<a id="#capture_clippy_output"></a>
+
+## capture_clippy_output
+
+<pre>
+capture_clippy_output(<a href="#capture_clippy_output-name">name</a>)
+</pre>
+
+Control whether to print clippy output or store it to a file, using the configured error_format.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="capture_clippy_output-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#error_format"></a>
+
+## error_format
+
+<pre>
+error_format(<a href="#error_format-name">name</a>)
+</pre>
+
+Change the [--error-format](https://doc.rust-lang.org/rustc/command-line-arguments.html#option-error-format) flag from the command line with `--@rules_rust//:error_format`. See rustc documentation for valid values.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="error_format-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#extra_rustc_flags"></a>
+
+## extra_rustc_flags
+
+<pre>
+extra_rustc_flags(<a href="#extra_rustc_flags-name">name</a>)
+</pre>
+
+Add additional rustc_flags from the command line with `--@rules_rust//:extra_rustc_flags`. This flag should only be used for flags that need to be applied across the entire build. For options that apply to individual crates, use the rustc_flags attribute on the individual crate's rule instead. NOTE: These flags not applied to the exec configuration (proc-macros, cargo_build_script, etc); use `--@rules_rust//:extra_exec_rustc_flags` to apply flags to the exec configuration.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="extra_rustc_flags-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#rust_binary"></a>
+
+## rust_binary
+
+<pre>
+rust_binary(<a href="#rust_binary-name">name</a>, <a href="#rust_binary-aliases">aliases</a>, <a href="#rust_binary-compile_data">compile_data</a>, <a href="#rust_binary-crate_features">crate_features</a>, <a href="#rust_binary-crate_name">crate_name</a>, <a href="#rust_binary-crate_root">crate_root</a>, <a href="#rust_binary-crate_type">crate_type</a>, <a href="#rust_binary-data">data</a>,
+            <a href="#rust_binary-deps">deps</a>, <a href="#rust_binary-edition">edition</a>, <a href="#rust_binary-linker_script">linker_script</a>, <a href="#rust_binary-out_binary">out_binary</a>, <a href="#rust_binary-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_binary-rustc_env">rustc_env</a>, <a href="#rust_binary-rustc_env_files">rustc_env_files</a>,
+            <a href="#rust_binary-rustc_flags">rustc_flags</a>, <a href="#rust_binary-srcs">srcs</a>, <a href="#rust_binary-stamp">stamp</a>, <a href="#rust_binary-version">version</a>)
+</pre>
+
+Builds a Rust binary crate.
+
+Example:
+
+Suppose you have the following directory structure for a Rust project with a
+library crate, `hello_lib`, and a binary crate, `hello_world` that uses the
+`hello_lib` library:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+    hello_world/
+        BUILD
+        src/
+            main.rs
+```
+
+`hello_lib/src/lib.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+```
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+```
+
+`hello_world/src/main.rs`:
+```rust
+extern crate hello_lib;
+
+fn main() {
+    let hello = hello_lib::Greeter::new("Hello");
+    hello.greet("world");
+}
+```
+
+`hello_world/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+rust_binary(
+    name = "hello_world",
+    srcs = ["src/main.rs"],
+    deps = ["//hello_lib"],
+)
+```
+
+Build and run `hello_world`:
+```
+$ bazel run //hello_world
+INFO: Found 1 target...
+Target //examples/rust/hello_world:hello_world up-to-date:
+bazel-bin/examples/rust/hello_world/hello_world
+INFO: Elapsed time: 1.308s, Critical Path: 1.22s
+
+INFO: Running command line: bazel-bin/examples/rust/hello_world/hello_world
+Hello world
+```
+
+On Windows, a PDB file containing debugging information is available under
+the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
+is available under the key `dsym_folder` in `OutputGroupInfo`.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_binary-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_binary-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_binary-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_binary-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_binary-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_binary-crate_type"></a>crate_type |  Crate type that will be passed to <code>rustc</code> to be used for building this crate.<br><br>This option is a temporary workaround and should be used only when building for WebAssembly targets (//rust/platform:wasi and //rust/platform:wasm).   | String | optional | "bin" |
+| <a id="rust_binary-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_binary-linker_script"></a>linker_script |  Link script to forward into linker via rustc options.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_binary-out_binary"></a>out_binary |  Force a target, regardless of it's <code>crate_type</code>, to always mark the file as executable. This attribute is only used to support wasm targets but is expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771.   | Boolean | optional | False |
+| <a id="rust_binary-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_binary-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_binary-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_binary-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_library"></a>
+
+## rust_library
+
+<pre>
+rust_library(<a href="#rust_library-name">name</a>, <a href="#rust_library-aliases">aliases</a>, <a href="#rust_library-compile_data">compile_data</a>, <a href="#rust_library-crate_features">crate_features</a>, <a href="#rust_library-crate_name">crate_name</a>, <a href="#rust_library-crate_root">crate_root</a>, <a href="#rust_library-data">data</a>, <a href="#rust_library-deps">deps</a>,
+             <a href="#rust_library-edition">edition</a>, <a href="#rust_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_library-rustc_env">rustc_env</a>, <a href="#rust_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_library-rustc_flags">rustc_flags</a>, <a href="#rust_library-srcs">srcs</a>, <a href="#rust_library-stamp">stamp</a>, <a href="#rust_library-version">version</a>)
+</pre>
+
+Builds a Rust library crate.
+
+Example:
+
+Suppose you have the following directory structure for a simple Rust library crate:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            greeter.rs
+            lib.rs
+```
+
+`hello_lib/src/greeter.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+```
+
+`hello_lib/src/lib.rs`:
+
+```rust
+pub mod greeter;
+```
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+)
+```
+
+Build the library:
+```output
+$ bazel build //hello_lib
+INFO: Found 1 target...
+Target //examples/rust/hello_lib:hello_lib up-to-date:
+bazel-bin/examples/rust/hello_lib/libhello_lib.rlib
+INFO: Elapsed time: 1.245s, Critical Path: 1.01s
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_proc_macro"></a>
+
+## rust_proc_macro
+
+<pre>
+rust_proc_macro(<a href="#rust_proc_macro-name">name</a>, <a href="#rust_proc_macro-aliases">aliases</a>, <a href="#rust_proc_macro-compile_data">compile_data</a>, <a href="#rust_proc_macro-crate_features">crate_features</a>, <a href="#rust_proc_macro-crate_name">crate_name</a>, <a href="#rust_proc_macro-crate_root">crate_root</a>, <a href="#rust_proc_macro-data">data</a>, <a href="#rust_proc_macro-deps">deps</a>,
+                <a href="#rust_proc_macro-edition">edition</a>, <a href="#rust_proc_macro-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_proc_macro-rustc_env">rustc_env</a>, <a href="#rust_proc_macro-rustc_env_files">rustc_env_files</a>, <a href="#rust_proc_macro-rustc_flags">rustc_flags</a>, <a href="#rust_proc_macro-srcs">srcs</a>, <a href="#rust_proc_macro-stamp">stamp</a>,
+                <a href="#rust_proc_macro-version">version</a>)
+</pre>
+
+Builds a Rust proc-macro crate.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proc_macro-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proc_macro-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_proc_macro-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_proc_macro-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_proc_macro-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_proc_macro-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_proc_macro-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_proc_macro-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_proc_macro-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_proc_macro-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_shared_library"></a>
+
+## rust_shared_library
+
+<pre>
+rust_shared_library(<a href="#rust_shared_library-name">name</a>, <a href="#rust_shared_library-aliases">aliases</a>, <a href="#rust_shared_library-compile_data">compile_data</a>, <a href="#rust_shared_library-crate_features">crate_features</a>, <a href="#rust_shared_library-crate_name">crate_name</a>, <a href="#rust_shared_library-crate_root">crate_root</a>, <a href="#rust_shared_library-data">data</a>, <a href="#rust_shared_library-deps">deps</a>,
+                    <a href="#rust_shared_library-edition">edition</a>, <a href="#rust_shared_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_shared_library-rustc_env">rustc_env</a>, <a href="#rust_shared_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_shared_library-rustc_flags">rustc_flags</a>, <a href="#rust_shared_library-srcs">srcs</a>, <a href="#rust_shared_library-stamp">stamp</a>,
+                    <a href="#rust_shared_library-version">version</a>)
+</pre>
+
+Builds a Rust shared library.
+
+This shared library will contain all transitively reachable crates and native objects.
+It is meant to be used when producing an artifact that is then consumed by some other build system
+(for example to produce a shared library that Python program links against).
+
+This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+When building the whole binary in Bazel, use `rust_library` instead.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_shared_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_shared_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_shared_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_shared_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_shared_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_shared_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_shared_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_shared_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_shared_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_shared_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_static_library"></a>
+
+## rust_static_library
+
+<pre>
+rust_static_library(<a href="#rust_static_library-name">name</a>, <a href="#rust_static_library-aliases">aliases</a>, <a href="#rust_static_library-compile_data">compile_data</a>, <a href="#rust_static_library-crate_features">crate_features</a>, <a href="#rust_static_library-crate_name">crate_name</a>, <a href="#rust_static_library-crate_root">crate_root</a>, <a href="#rust_static_library-data">data</a>, <a href="#rust_static_library-deps">deps</a>,
+                    <a href="#rust_static_library-edition">edition</a>, <a href="#rust_static_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_static_library-rustc_env">rustc_env</a>, <a href="#rust_static_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_static_library-rustc_flags">rustc_flags</a>, <a href="#rust_static_library-srcs">srcs</a>, <a href="#rust_static_library-stamp">stamp</a>,
+                    <a href="#rust_static_library-version">version</a>)
+</pre>
+
+Builds a Rust static library.
+
+This static library will contain all transitively reachable crates and native objects.
+It is meant to be used when producing an artifact that is then consumed by some other build system
+(for example to produce an archive that Python program links against).
+
+This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+When building the whole binary in Bazel, use `rust_library` instead.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_static_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_static_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_static_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_static_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_static_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_static_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_static_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_static_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_static_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_static_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_test"></a>
+
+## rust_test
+
+<pre>
+rust_test(<a href="#rust_test-name">name</a>, <a href="#rust_test-aliases">aliases</a>, <a href="#rust_test-compile_data">compile_data</a>, <a href="#rust_test-crate">crate</a>, <a href="#rust_test-crate_features">crate_features</a>, <a href="#rust_test-crate_name">crate_name</a>, <a href="#rust_test-crate_root">crate_root</a>, <a href="#rust_test-data">data</a>, <a href="#rust_test-deps">deps</a>,
+          <a href="#rust_test-edition">edition</a>, <a href="#rust_test-env">env</a>, <a href="#rust_test-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_test-rustc_env">rustc_env</a>, <a href="#rust_test-rustc_env_files">rustc_env_files</a>, <a href="#rust_test-rustc_flags">rustc_flags</a>, <a href="#rust_test-srcs">srcs</a>, <a href="#rust_test-stamp">stamp</a>,
+          <a href="#rust_test-use_libtest_harness">use_libtest_harness</a>, <a href="#rust_test-version">version</a>)
+</pre>
+
+Builds a Rust test crate.
+
+Examples:
+
+Suppose you have the following directory structure for a Rust library crate         with unit test code in the library sources:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+```
+
+`hello_lib/src/lib.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) -> String {
+        format!("{} {}", &self.greeting, thing)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Greeter;
+
+    #[test]
+    fn test_greeting() {
+        let hello = Greeter::new("Hi");
+        assert_eq!("Hi Rust", hello.greet("Rust"));
+    }
+}
+```
+
+To build and run the tests, simply add a `rust_test` rule with no `srcs` and         only depends on the `hello_lib` `rust_library` target:
+
+`hello_lib/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "hello_lib_test",
+    deps = [":hello_lib"],
+)
+```
+
+Run the test with `bazel build //hello_lib:hello_lib_test`.
+
+To run a crate or lib with the `#[cfg(test)]` configuration, handling inline         tests, you should specify the crate directly like so.
+
+```python
+rust_test(
+    name = "hello_lib_test",
+    crate = ":hello_lib",
+    # You may add other deps that are specific to the test configuration
+    deps = ["//some/dev/dep"],
+)
+```
+
+### Example: `test` directory
+
+Integration tests that live in the [`tests` directory][int-tests], they are         essentially built as separate crates. Suppose you have the following directory         structure where `greeting.rs` is an integration test for the `hello_lib`         library crate:
+
+[int-tests]: http://doc.rust-lang.org/book/testing.html#the-tests-directory
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+        tests/
+            greeting.rs
+```
+
+`hello_lib/tests/greeting.rs`:
+```rust
+extern crate hello_lib;
+
+use hello_lib;
+
+#[test]
+fn test_greeting() {
+    let hello = greeter::Greeter::new("Hello");
+    assert_eq!("Hello world", hello.greeting("world"));
+}
+```
+
+To build the `greeting.rs` integration test, simply add a `rust_test` target
+with `greeting.rs` in `srcs` and a dependency on the `hello_lib` target:
+
+`hello_lib/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Run the test with `bazel build //hello_lib:hello_lib_test`.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_test-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_test-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-crate"></a>crate |  Target inline tests declared in the given crate<br><br>These tests are typically those that would be held out under <code>#[cfg(test)]</code> declarations.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_test-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_test-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_test-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_test-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_test-env"></a>env |  Specifies additional environment variables to set when the test is executed by bazel test. Values are subject to <code>$(rootpath)</code>, <code>$(execpath)</code>, location, and ["Make variable"](https://docs.bazel.build/versions/master/be/make-variables.html) substitution.<br><br>Execpath returns absolute path, and in order to be able to construct the absolute path we need to wrap the test binary in a launcher. Using a launcher comes with complications, such as more complicated debugger attachment.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_test-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_test-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_test-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_test-use_libtest_harness"></a>use_libtest_harness |  Whether to use <code>libtest</code>. For targets using this flag, individual tests can be run by using the [--test_arg](https://docs.bazel.build/versions/4.0.0/command-line-reference.html#flag--test_arg) flag. E.g. <code>bazel test //src:rust_test --test_arg=foo::test::test_fn</code>.   | Boolean | optional | True |
+| <a id="rust_test-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_test_suite"></a>
+
+## rust_test_suite
+
+<pre>
+rust_test_suite(<a href="#rust_test_suite-name">name</a>, <a href="#rust_test_suite-srcs">srcs</a>, <a href="#rust_test_suite-kwargs">kwargs</a>)
+</pre>
+
+A rule for creating a test suite for a set of `rust_test` targets.
+
+This rule can be used for setting up typical rust [integration tests][it]. Given the following
+directory structure:
+
+```text
+[crate]/
+    BUILD.bazel
+    src/
+        lib.rs
+        main.rs
+    tests/
+        integrated_test_a.rs
+        integrated_test_b.rs
+        integrated_test_c.rs
+        patterns/
+            fibonacci_test.rs
+```
+
+The rule can be used to generate [rust_test](#rust_test) targets for each source file under `tests`
+and a [test_suite][ts] which encapsulates all tests.
+
+```python
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test_suite")
+
+rust_library(
+    name = "math_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_binary(
+    name = "math_bin",
+    srcs = ["src/main.rs"],
+)
+
+rust_test_suite(
+    name = "integrated_tests_suite",
+    srcs = glob(["tests/**"]),
+    deps = [":math_lib"],
+)
+```
+
+[it]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
+[ts]: https://docs.bazel.build/versions/master/be/general.html#test_suite
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_test_suite-name"></a>name |  The name of the <code>test_suite</code>.   |  none |
+| <a id="rust_test_suite-srcs"></a>srcs |  All test sources, typically <code>glob(["tests/**/*.rs"])</code>.   |  none |
+| <a id="rust_test_suite-kwargs"></a>kwargs |  Additional keyword arguments for the underyling [rust_test](#rust_test) targets. The <code>tags</code> argument is also passed to the generated <code>test_suite</code> target.   |  none |
+
+
diff --git a/third_party/rules_rust/docs/flatten.md b/third_party/rules_rust/docs/flatten.md
new file mode 100644
index 0000000..f650bc9
--- /dev/null
+++ b/third_party/rules_rust/docs/flatten.md
@@ -0,0 +1,1837 @@
+# Rust rules
+
+* [CrateInfo](#CrateInfo)
+* [DepInfo](#DepInfo)
+* [StdLibInfo](#StdLibInfo)
+* [capture_clippy_output](#capture_clippy_output)
+* [cargo_bootstrap_repository](#cargo_bootstrap_repository)
+* [cargo_build_script](#cargo_build_script)
+* [cargo_env](#cargo_env)
+* [error_format](#error_format)
+* [extra_rustc_flags](#extra_rustc_flags)
+* [fail_when_enabled](#fail_when_enabled)
+* [incompatible_flag](#incompatible_flag)
+* [rules_rust_dependencies](#rules_rust_dependencies)
+* [rust_analyzer](#rust_analyzer)
+* [rust_analyzer_aspect](#rust_analyzer_aspect)
+* [rust_binary](#rust_binary)
+* [rust_bindgen](#rust_bindgen)
+* [rust_bindgen_library](#rust_bindgen_library)
+* [rust_bindgen_repositories](#rust_bindgen_repositories)
+* [rust_bindgen_toolchain](#rust_bindgen_toolchain)
+* [rust_clippy](#rust_clippy)
+* [rust_clippy_aspect](#rust_clippy_aspect)
+* [rust_doc](#rust_doc)
+* [rust_doc_test](#rust_doc_test)
+* [rust_grpc_library](#rust_grpc_library)
+* [rust_library](#rust_library)
+* [rust_proc_macro](#rust_proc_macro)
+* [rust_proto_library](#rust_proto_library)
+* [rust_proto_repositories](#rust_proto_repositories)
+* [rust_proto_toolchain](#rust_proto_toolchain)
+* [rust_proto_transitive_repositories](#rust_proto_transitive_repositories)
+* [rust_register_toolchains](#rust_register_toolchains)
+* [rust_repositories](#rust_repositories)
+* [rust_repository_set](#rust_repository_set)
+* [rust_shared_library](#rust_shared_library)
+* [rust_static_library](#rust_static_library)
+* [rust_stdlib_filegroup](#rust_stdlib_filegroup)
+* [rust_test](#rust_test)
+* [rust_test_suite](#rust_test_suite)
+* [rust_toolchain](#rust_toolchain)
+* [rust_toolchain_repository](#rust_toolchain_repository)
+* [rust_toolchain_repository_proxy](#rust_toolchain_repository_proxy)
+* [rust_wasm_bindgen](#rust_wasm_bindgen)
+* [rust_wasm_bindgen_repositories](#rust_wasm_bindgen_repositories)
+* [rust_wasm_bindgen_toolchain](#rust_wasm_bindgen_toolchain)
+* [rustfmt_aspect](#rustfmt_aspect)
+* [rustfmt_test](#rustfmt_test)
+
+
+<a id="#capture_clippy_output"></a>
+
+## capture_clippy_output
+
+<pre>
+capture_clippy_output(<a href="#capture_clippy_output-name">name</a>)
+</pre>
+
+Control whether to print clippy output or store it to a file, using the configured error_format.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="capture_clippy_output-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#cargo_bootstrap_repository"></a>
+
+## cargo_bootstrap_repository
+
+<pre>
+cargo_bootstrap_repository(<a href="#cargo_bootstrap_repository-name">name</a>, <a href="#cargo_bootstrap_repository-binary">binary</a>, <a href="#cargo_bootstrap_repository-build_mode">build_mode</a>, <a href="#cargo_bootstrap_repository-cargo_lockfile">cargo_lockfile</a>, <a href="#cargo_bootstrap_repository-cargo_toml">cargo_toml</a>, <a href="#cargo_bootstrap_repository-env">env</a>, <a href="#cargo_bootstrap_repository-env_label">env_label</a>,
+                           <a href="#cargo_bootstrap_repository-iso_date">iso_date</a>, <a href="#cargo_bootstrap_repository-repo_mapping">repo_mapping</a>, <a href="#cargo_bootstrap_repository-rust_toolchain_cargo_template">rust_toolchain_cargo_template</a>,
+                           <a href="#cargo_bootstrap_repository-rust_toolchain_repository_template">rust_toolchain_repository_template</a>, <a href="#cargo_bootstrap_repository-rust_toolchain_rustc_template">rust_toolchain_rustc_template</a>, <a href="#cargo_bootstrap_repository-srcs">srcs</a>,
+                           <a href="#cargo_bootstrap_repository-timeout">timeout</a>, <a href="#cargo_bootstrap_repository-version">version</a>)
+</pre>
+
+A rule for bootstrapping a Rust binary using [Cargo](https://doc.rust-lang.org/cargo/)
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="cargo_bootstrap_repository-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="cargo_bootstrap_repository-binary"></a>binary |  The binary to build (the <code>--bin</code> parameter for Cargo). If left empty, the repository name will be used.   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-build_mode"></a>build_mode |  The build mode the binary should be built with   | String | optional | "release" |
+| <a id="cargo_bootstrap_repository-cargo_lockfile"></a>cargo_lockfile |  The lockfile of the crate_universe resolver   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="cargo_bootstrap_repository-cargo_toml"></a>cargo_toml |  The path of the crate_universe resolver manifest (<code>Cargo.toml</code> file)   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="cargo_bootstrap_repository-env"></a>env |  A mapping of platform triple to a set of environment variables. See [cargo_env](#cargo_env) for usage details. Additionally, the platform triple <code>*</code> applies to all platforms.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="cargo_bootstrap_repository-env_label"></a>env_label |  A mapping of platform triple to a set of environment variables. This attribute differs from <code>env</code> in that all variables passed here must be fully qualified labels of files. See [cargo_env](#cargo_env) for usage details. Additionally, the platform triple <code>*</code> applies to all platforms.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="cargo_bootstrap_repository-iso_date"></a>iso_date |  The iso_date of cargo binary the resolver should use. Note: This can only be set if <code>version</code> is <code>beta</code> or <code>nightly</code>   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="cargo_bootstrap_repository-rust_toolchain_cargo_template"></a>rust_toolchain_cargo_template |  The template to use for finding the host <code>cargo</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), and <code>{tool}</code> (eg. 'rustc.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="cargo_bootstrap_repository-rust_toolchain_repository_template"></a>rust_toolchain_repository_template |  **Deprecated**: Please use <code>rust_toolchain_cargo_template</code> and <code>rust_toolchain_rustc_template</code>   | String | optional | "" |
+| <a id="cargo_bootstrap_repository-rust_toolchain_rustc_template"></a>rust_toolchain_rustc_template |  The template to use for finding the host <code>rustc</code> binary. <code>{version}</code> (eg. '1.53.0'), <code>{triple}</code> (eg. 'x86_64-unknown-linux-gnu'), <code>{arch}</code> (eg. 'aarch64'), <code>{vendor}</code> (eg. 'unknown'), <code>{system}</code> (eg. 'darwin'), and <code>{tool}</code> (eg. 'rustc.exe') will be replaced in the string if present.   | String | optional | "@rust_{system}_{arch}//:bin/{tool}" |
+| <a id="cargo_bootstrap_repository-srcs"></a>srcs |  Souce files of the crate to build. Passing source files here can be used to trigger rebuilds when changes are made   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="cargo_bootstrap_repository-timeout"></a>timeout |  Maximum duration of the Cargo build command in seconds   | Integer | optional | 600 |
+| <a id="cargo_bootstrap_repository-version"></a>version |  The version of cargo the resolver should use   | String | optional | "1.59.0" |
+
+
+<a id="#error_format"></a>
+
+## error_format
+
+<pre>
+error_format(<a href="#error_format-name">name</a>)
+</pre>
+
+Change the [--error-format](https://doc.rust-lang.org/rustc/command-line-arguments.html#option-error-format) flag from the command line with `--@rules_rust//:error_format`. See rustc documentation for valid values.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="error_format-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#extra_rustc_flags"></a>
+
+## extra_rustc_flags
+
+<pre>
+extra_rustc_flags(<a href="#extra_rustc_flags-name">name</a>)
+</pre>
+
+Add additional rustc_flags from the command line with `--@rules_rust//:extra_rustc_flags`. This flag should only be used for flags that need to be applied across the entire build. For options that apply to individual crates, use the rustc_flags attribute on the individual crate's rule instead. NOTE: These flags not applied to the exec configuration (proc-macros, cargo_build_script, etc); use `--@rules_rust//:extra_exec_rustc_flags` to apply flags to the exec configuration.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="extra_rustc_flags-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+
+
+<a id="#incompatible_flag"></a>
+
+## incompatible_flag
+
+<pre>
+incompatible_flag(<a href="#incompatible_flag-name">name</a>, <a href="#incompatible_flag-issue">issue</a>)
+</pre>
+
+A rule defining an incompatible flag.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="incompatible_flag-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="incompatible_flag-issue"></a>issue |  The link to the github issue associated with this flag   | String | required |  |
+
+
+<a id="#rust_analyzer"></a>
+
+## rust_analyzer
+
+<pre>
+rust_analyzer(<a href="#rust_analyzer-name">name</a>, <a href="#rust_analyzer-targets">targets</a>)
+</pre>
+
+Deprecated: gen_rust_project can now create a rust-project.json without a rust_analyzer rule.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_analyzer-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_analyzer-targets"></a>targets |  List of all targets to be included in the index   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_binary"></a>
+
+## rust_binary
+
+<pre>
+rust_binary(<a href="#rust_binary-name">name</a>, <a href="#rust_binary-aliases">aliases</a>, <a href="#rust_binary-compile_data">compile_data</a>, <a href="#rust_binary-crate_features">crate_features</a>, <a href="#rust_binary-crate_name">crate_name</a>, <a href="#rust_binary-crate_root">crate_root</a>, <a href="#rust_binary-crate_type">crate_type</a>, <a href="#rust_binary-data">data</a>,
+            <a href="#rust_binary-deps">deps</a>, <a href="#rust_binary-edition">edition</a>, <a href="#rust_binary-linker_script">linker_script</a>, <a href="#rust_binary-out_binary">out_binary</a>, <a href="#rust_binary-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_binary-rustc_env">rustc_env</a>, <a href="#rust_binary-rustc_env_files">rustc_env_files</a>,
+            <a href="#rust_binary-rustc_flags">rustc_flags</a>, <a href="#rust_binary-srcs">srcs</a>, <a href="#rust_binary-stamp">stamp</a>, <a href="#rust_binary-version">version</a>)
+</pre>
+
+Builds a Rust binary crate.
+
+Example:
+
+Suppose you have the following directory structure for a Rust project with a
+library crate, `hello_lib`, and a binary crate, `hello_world` that uses the
+`hello_lib` library:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+    hello_world/
+        BUILD
+        src/
+            main.rs
+```
+
+`hello_lib/src/lib.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+```
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+```
+
+`hello_world/src/main.rs`:
+```rust
+extern crate hello_lib;
+
+fn main() {
+    let hello = hello_lib::Greeter::new("Hello");
+    hello.greet("world");
+}
+```
+
+`hello_world/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+rust_binary(
+    name = "hello_world",
+    srcs = ["src/main.rs"],
+    deps = ["//hello_lib"],
+)
+```
+
+Build and run `hello_world`:
+```
+$ bazel run //hello_world
+INFO: Found 1 target...
+Target //examples/rust/hello_world:hello_world up-to-date:
+bazel-bin/examples/rust/hello_world/hello_world
+INFO: Elapsed time: 1.308s, Critical Path: 1.22s
+
+INFO: Running command line: bazel-bin/examples/rust/hello_world/hello_world
+Hello world
+```
+
+On Windows, a PDB file containing debugging information is available under
+the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
+is available under the key `dsym_folder` in `OutputGroupInfo`.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_binary-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_binary-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_binary-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_binary-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_binary-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_binary-crate_type"></a>crate_type |  Crate type that will be passed to <code>rustc</code> to be used for building this crate.<br><br>This option is a temporary workaround and should be used only when building for WebAssembly targets (//rust/platform:wasi and //rust/platform:wasm).   | String | optional | "bin" |
+| <a id="rust_binary-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_binary-linker_script"></a>linker_script |  Link script to forward into linker via rustc options.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_binary-out_binary"></a>out_binary |  Force a target, regardless of it's <code>crate_type</code>, to always mark the file as executable. This attribute is only used to support wasm targets but is expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771.   | Boolean | optional | False |
+| <a id="rust_binary-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_binary-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_binary-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_binary-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_binary-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_bindgen"></a>
+
+## rust_bindgen
+
+<pre>
+rust_bindgen(<a href="#rust_bindgen-name">name</a>, <a href="#rust_bindgen-bindgen_flags">bindgen_flags</a>, <a href="#rust_bindgen-cc_lib">cc_lib</a>, <a href="#rust_bindgen-clang_flags">clang_flags</a>, <a href="#rust_bindgen-header">header</a>, <a href="#rust_bindgen-rustfmt">rustfmt</a>)
+</pre>
+
+Generates a rust source file from a cc_library and a header.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_bindgen-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_bindgen-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.   | List of strings | optional | [] |
+| <a id="rust_bindgen-cc_lib"></a>cc_lib |  The cc_library that contains the .h file. This is used to find the transitive includes.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen-clang_flags"></a>clang_flags |  Flags to pass directly to the clang executable.   | List of strings | optional | [] |
+| <a id="rust_bindgen-header"></a>header |  The .h file to generate bindings for.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen-rustfmt"></a>rustfmt |  Enable or disable running rustfmt on the generated file.   | Boolean | optional | True |
+
+
+<a id="#rust_bindgen_toolchain"></a>
+
+## rust_bindgen_toolchain
+
+<pre>
+rust_bindgen_toolchain(<a href="#rust_bindgen_toolchain-name">name</a>, <a href="#rust_bindgen_toolchain-bindgen">bindgen</a>, <a href="#rust_bindgen_toolchain-clang">clang</a>, <a href="#rust_bindgen_toolchain-libclang">libclang</a>, <a href="#rust_bindgen_toolchain-libstdcxx">libstdcxx</a>, <a href="#rust_bindgen_toolchain-rustfmt">rustfmt</a>)
+</pre>
+
+The tools required for the `rust_bindgen` rule.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_bindgen_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_bindgen_toolchain-bindgen"></a>bindgen |  The label of a <code>bindgen</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-clang"></a>clang |  The label of a <code>clang</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-libclang"></a>libclang |  A cc_library that provides bindgen's runtime dependency on libclang.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-libstdcxx"></a>libstdcxx |  A cc_library that satisfies libclang's libstdc++ dependency. This is used to make the execution of clang hermetic. If None, system libraries will be used instead.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-rustfmt"></a>rustfmt |  The label of a <code>rustfmt</code> executable. If this is not provided, falls back to the rust_toolchain rustfmt.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+
+
+<a id="#rust_clippy"></a>
+
+## rust_clippy
+
+<pre>
+rust_clippy(<a href="#rust_clippy-name">name</a>, <a href="#rust_clippy-deps">deps</a>)
+</pre>
+
+Executes the clippy checker on a specific target.
+
+Similar to `rust_clippy_aspect`, but allows specifying a list of dependencies within the build system.
+
+For example, given the following example targets:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Rust clippy can be set as a build target with the following:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_clippy")
+
+rust_clippy(
+    name = "hello_library_clippy",
+    testonly = True,
+    deps = [
+        ":hello_lib",
+        ":greeting_test",
+    ],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_clippy-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_clippy-deps"></a>deps |  Rust targets to run clippy on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_doc"></a>
+
+## rust_doc
+
+<pre>
+rust_doc(<a href="#rust_doc-name">name</a>, <a href="#rust_doc-crate">crate</a>, <a href="#rust_doc-html_after_content">html_after_content</a>, <a href="#rust_doc-html_before_content">html_before_content</a>, <a href="#rust_doc-html_in_header">html_in_header</a>, <a href="#rust_doc-markdown_css">markdown_css</a>)
+</pre>
+
+Generates code documentation.
+
+Example:
+Suppose you have the following directory structure for a Rust library crate:
+
+```
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+```
+
+To build [`rustdoc`][rustdoc] documentation for the `hello_lib` crate, define     a `rust_doc` rule that depends on the the `hello_lib` `rust_library` target:
+
+[rustdoc]: https://doc.rust-lang.org/book/documentation.html
+
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_doc(
+    name = "hello_lib_doc",
+    crate = ":hello_lib",
+)
+```
+
+Running `bazel build //hello_lib:hello_lib_doc` will build a zip file containing     the documentation for the `hello_lib` library crate generated by `rustdoc`.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_doc-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_doc-crate"></a>crate |  The label of the target to generate code documentation for.<br><br><code>rust_doc</code> can generate HTML code documentation for the source files of <code>rust_library</code> or <code>rust_binary</code> targets.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_doc-html_after_content"></a>html_after_content |  File to add in <code>&lt;body&gt;</code>, after content.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-html_before_content"></a>html_before_content |  File to add in <code>&lt;body&gt;</code>, before content.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-html_in_header"></a>html_in_header |  File to add to <code>&lt;head&gt;</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-markdown_css"></a>markdown_css |  CSS files to include via <code>&lt;link&gt;</code> in a rendered Markdown file.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_doc_test"></a>
+
+## rust_doc_test
+
+<pre>
+rust_doc_test(<a href="#rust_doc_test-name">name</a>, <a href="#rust_doc_test-crate">crate</a>)
+</pre>
+
+Runs Rust documentation tests.
+
+Example:
+
+Suppose you have the following directory structure for a Rust library crate:
+
+```output
+[workspace]/
+WORKSPACE
+hello_lib/
+    BUILD
+    src/
+        lib.rs
+```
+
+To run [documentation tests][doc-test] for the `hello_lib` crate, define a `rust_doc_test`         target that depends on the `hello_lib` `rust_library` target:
+
+[doc-test]: https://doc.rust-lang.org/book/documentation.html#documentation-as-tests
+
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_doc_test(
+    name = "hello_lib_doc_test",
+    crate = ":hello_lib",
+)
+```
+
+Running `bazel test //hello_lib:hello_lib_doc_test` will run all documentation tests for the `hello_lib` library crate.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_doc_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_doc_test-crate"></a>crate |  The label of the target to generate code documentation for. <code>rust_doc_test</code> can generate HTML code documentation for the source files of <code>rust_library</code> or <code>rust_binary</code> targets.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+
+
+<a id="#rust_grpc_library"></a>
+
+## rust_grpc_library
+
+<pre>
+rust_grpc_library(<a href="#rust_grpc_library-name">name</a>, <a href="#rust_grpc_library-deps">deps</a>, <a href="#rust_grpc_library-rust_deps">rust_deps</a>)
+</pre>
+
+Builds a Rust library crate from a set of `proto_library`s suitable for gRPC.
+
+Example:
+
+```python
+load("//proto:proto.bzl", "rust_grpc_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_grpc_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_service",
+    srcs = ["my_service.rs"],
+    deps = [":rust"],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_grpc_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_grpc_library-deps"></a>deps |  List of proto_library dependencies that will be built. One crate for each proto_library will be created with the corresponding gRPC stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+| <a id="rust_grpc_library-rust_deps"></a>rust_deps |  The crates the generated library depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_library"></a>
+
+## rust_library
+
+<pre>
+rust_library(<a href="#rust_library-name">name</a>, <a href="#rust_library-aliases">aliases</a>, <a href="#rust_library-compile_data">compile_data</a>, <a href="#rust_library-crate_features">crate_features</a>, <a href="#rust_library-crate_name">crate_name</a>, <a href="#rust_library-crate_root">crate_root</a>, <a href="#rust_library-data">data</a>, <a href="#rust_library-deps">deps</a>,
+             <a href="#rust_library-edition">edition</a>, <a href="#rust_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_library-rustc_env">rustc_env</a>, <a href="#rust_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_library-rustc_flags">rustc_flags</a>, <a href="#rust_library-srcs">srcs</a>, <a href="#rust_library-stamp">stamp</a>, <a href="#rust_library-version">version</a>)
+</pre>
+
+Builds a Rust library crate.
+
+Example:
+
+Suppose you have the following directory structure for a simple Rust library crate:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            greeter.rs
+            lib.rs
+```
+
+`hello_lib/src/greeter.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+```
+
+`hello_lib/src/lib.rs`:
+
+```rust
+pub mod greeter;
+```
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+)
+```
+
+Build the library:
+```output
+$ bazel build //hello_lib
+INFO: Found 1 target...
+Target //examples/rust/hello_lib:hello_lib up-to-date:
+bazel-bin/examples/rust/hello_lib/libhello_lib.rlib
+INFO: Elapsed time: 1.245s, Critical Path: 1.01s
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_proc_macro"></a>
+
+## rust_proc_macro
+
+<pre>
+rust_proc_macro(<a href="#rust_proc_macro-name">name</a>, <a href="#rust_proc_macro-aliases">aliases</a>, <a href="#rust_proc_macro-compile_data">compile_data</a>, <a href="#rust_proc_macro-crate_features">crate_features</a>, <a href="#rust_proc_macro-crate_name">crate_name</a>, <a href="#rust_proc_macro-crate_root">crate_root</a>, <a href="#rust_proc_macro-data">data</a>, <a href="#rust_proc_macro-deps">deps</a>,
+                <a href="#rust_proc_macro-edition">edition</a>, <a href="#rust_proc_macro-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_proc_macro-rustc_env">rustc_env</a>, <a href="#rust_proc_macro-rustc_env_files">rustc_env_files</a>, <a href="#rust_proc_macro-rustc_flags">rustc_flags</a>, <a href="#rust_proc_macro-srcs">srcs</a>, <a href="#rust_proc_macro-stamp">stamp</a>,
+                <a href="#rust_proc_macro-version">version</a>)
+</pre>
+
+Builds a Rust proc-macro crate.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proc_macro-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proc_macro-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_proc_macro-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_proc_macro-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_proc_macro-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_proc_macro-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_proc_macro-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_proc_macro-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_proc_macro-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_proc_macro-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_proc_macro-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_proto_library"></a>
+
+## rust_proto_library
+
+<pre>
+rust_proto_library(<a href="#rust_proto_library-name">name</a>, <a href="#rust_proto_library-deps">deps</a>, <a href="#rust_proto_library-rust_deps">rust_deps</a>)
+</pre>
+
+Builds a Rust library crate from a set of `proto_library`s.
+
+Example:
+
+```python
+load("@rules_rust//proto:proto.bzl", "rust_proto_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_proto_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_proto_binary",
+    srcs = ["my_proto_binary.rs"],
+    deps = [":rust"],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proto_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proto_library-deps"></a>deps |  List of proto_library dependencies that will be built. One crate for each proto_library will be created with the corresponding stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+| <a id="rust_proto_library-rust_deps"></a>rust_deps |  The crates the generated library depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_proto_toolchain"></a>
+
+## rust_proto_toolchain
+
+<pre>
+rust_proto_toolchain(<a href="#rust_proto_toolchain-name">name</a>, <a href="#rust_proto_toolchain-edition">edition</a>, <a href="#rust_proto_toolchain-grpc_compile_deps">grpc_compile_deps</a>, <a href="#rust_proto_toolchain-grpc_plugin">grpc_plugin</a>, <a href="#rust_proto_toolchain-proto_compile_deps">proto_compile_deps</a>,
+                     <a href="#rust_proto_toolchain-proto_plugin">proto_plugin</a>, <a href="#rust_proto_toolchain-protoc">protoc</a>)
+</pre>
+
+Declares a Rust Proto toolchain for use.
+
+This is used to configure proto compilation and can be used to set different protobuf compiler plugin.
+
+Example:
+
+Suppose a new nicer gRPC plugin has came out. The new plugin can be used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//proto:toolchain.bzl', 'rust_proto_toolchain')
+
+rust_proto_toolchain(
+   name="rust_proto_impl",
+   grpc_plugin="@rust_grpc//:grpc_plugin",
+   grpc_compile_deps=["@rust_grpc//:grpc_deps"],
+)
+
+toolchain(
+    name="rust_proto",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_proto_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to register_toolchains in the WORKSPACE, or pass it to the `--extra_toolchains` flag for Bazel, and it will be used.
+
+See @rules_rust//proto:BUILD for examples of defining the toolchain.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proto_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proto_toolchain-edition"></a>edition |  The edition used by the generated rust source.   | String | optional | "2018" |
+| <a id="rust_proto_toolchain-grpc_compile_deps"></a>grpc_compile_deps |  The crates the generated grpc libraries depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [Label("//proto/raze:protobuf"), Label("//proto/raze:grpc"), Label("//proto/raze:tls_api"), Label("//proto/raze:tls_api_stub")] |
+| <a id="rust_proto_toolchain-grpc_plugin"></a>grpc_plugin |  The location of the Rust protobuf compiler plugin to generate rust gRPC stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | //proto:protoc_gen_rust_grpc |
+| <a id="rust_proto_toolchain-proto_compile_deps"></a>proto_compile_deps |  The crates the generated protobuf libraries depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [Label("//proto/raze:protobuf")] |
+| <a id="rust_proto_toolchain-proto_plugin"></a>proto_plugin |  The location of the Rust protobuf compiler plugin used to generate rust sources.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | //proto:protoc_gen_rust |
+| <a id="rust_proto_toolchain-protoc"></a>protoc |  The location of the <code>protoc</code> binary. It should be an executable target.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | @com_google_protobuf//:protoc |
+
+
+<a id="#rust_shared_library"></a>
+
+## rust_shared_library
+
+<pre>
+rust_shared_library(<a href="#rust_shared_library-name">name</a>, <a href="#rust_shared_library-aliases">aliases</a>, <a href="#rust_shared_library-compile_data">compile_data</a>, <a href="#rust_shared_library-crate_features">crate_features</a>, <a href="#rust_shared_library-crate_name">crate_name</a>, <a href="#rust_shared_library-crate_root">crate_root</a>, <a href="#rust_shared_library-data">data</a>, <a href="#rust_shared_library-deps">deps</a>,
+                    <a href="#rust_shared_library-edition">edition</a>, <a href="#rust_shared_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_shared_library-rustc_env">rustc_env</a>, <a href="#rust_shared_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_shared_library-rustc_flags">rustc_flags</a>, <a href="#rust_shared_library-srcs">srcs</a>, <a href="#rust_shared_library-stamp">stamp</a>,
+                    <a href="#rust_shared_library-version">version</a>)
+</pre>
+
+Builds a Rust shared library.
+
+This shared library will contain all transitively reachable crates and native objects.
+It is meant to be used when producing an artifact that is then consumed by some other build system
+(for example to produce a shared library that Python program links against).
+
+This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+When building the whole binary in Bazel, use `rust_library` instead.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_shared_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_shared_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_shared_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_shared_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_shared_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_shared_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_shared_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_shared_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_shared_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_shared_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_shared_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_static_library"></a>
+
+## rust_static_library
+
+<pre>
+rust_static_library(<a href="#rust_static_library-name">name</a>, <a href="#rust_static_library-aliases">aliases</a>, <a href="#rust_static_library-compile_data">compile_data</a>, <a href="#rust_static_library-crate_features">crate_features</a>, <a href="#rust_static_library-crate_name">crate_name</a>, <a href="#rust_static_library-crate_root">crate_root</a>, <a href="#rust_static_library-data">data</a>, <a href="#rust_static_library-deps">deps</a>,
+                    <a href="#rust_static_library-edition">edition</a>, <a href="#rust_static_library-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_static_library-rustc_env">rustc_env</a>, <a href="#rust_static_library-rustc_env_files">rustc_env_files</a>, <a href="#rust_static_library-rustc_flags">rustc_flags</a>, <a href="#rust_static_library-srcs">srcs</a>, <a href="#rust_static_library-stamp">stamp</a>,
+                    <a href="#rust_static_library-version">version</a>)
+</pre>
+
+Builds a Rust static library.
+
+This static library will contain all transitively reachable crates and native objects.
+It is meant to be used when producing an artifact that is then consumed by some other build system
+(for example to produce an archive that Python program links against).
+
+This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+When building the whole binary in Bazel, use `rust_library` instead.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_static_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_static_library-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_static_library-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_static_library-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_static_library-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_static_library-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_static_library-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_static_library-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_static_library-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_static_library-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_static_library-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_stdlib_filegroup"></a>
+
+## rust_stdlib_filegroup
+
+<pre>
+rust_stdlib_filegroup(<a href="#rust_stdlib_filegroup-name">name</a>, <a href="#rust_stdlib_filegroup-srcs">srcs</a>)
+</pre>
+
+A dedicated filegroup-like rule for Rust stdlib artifacts.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_stdlib_filegroup-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_stdlib_filegroup-srcs"></a>srcs |  The list of targets/files that are components of the rust-stdlib file group   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+
+
+<a id="#rust_test"></a>
+
+## rust_test
+
+<pre>
+rust_test(<a href="#rust_test-name">name</a>, <a href="#rust_test-aliases">aliases</a>, <a href="#rust_test-compile_data">compile_data</a>, <a href="#rust_test-crate">crate</a>, <a href="#rust_test-crate_features">crate_features</a>, <a href="#rust_test-crate_name">crate_name</a>, <a href="#rust_test-crate_root">crate_root</a>, <a href="#rust_test-data">data</a>, <a href="#rust_test-deps">deps</a>,
+          <a href="#rust_test-edition">edition</a>, <a href="#rust_test-env">env</a>, <a href="#rust_test-proc_macro_deps">proc_macro_deps</a>, <a href="#rust_test-rustc_env">rustc_env</a>, <a href="#rust_test-rustc_env_files">rustc_env_files</a>, <a href="#rust_test-rustc_flags">rustc_flags</a>, <a href="#rust_test-srcs">srcs</a>, <a href="#rust_test-stamp">stamp</a>,
+          <a href="#rust_test-use_libtest_harness">use_libtest_harness</a>, <a href="#rust_test-version">version</a>)
+</pre>
+
+Builds a Rust test crate.
+
+Examples:
+
+Suppose you have the following directory structure for a Rust library crate         with unit test code in the library sources:
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+```
+
+`hello_lib/src/lib.rs`:
+```rust
+pub struct Greeter {
+    greeting: String,
+}
+
+impl Greeter {
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter { greeting: greeting.to_string(), }
+    }
+
+    pub fn greet(&self, thing: &str) -> String {
+        format!("{} {}", &self.greeting, thing)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Greeter;
+
+    #[test]
+    fn test_greeting() {
+        let hello = Greeter::new("Hi");
+        assert_eq!("Hi Rust", hello.greet("Rust"));
+    }
+}
+```
+
+To build and run the tests, simply add a `rust_test` rule with no `srcs` and         only depends on the `hello_lib` `rust_library` target:
+
+`hello_lib/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "hello_lib_test",
+    deps = [":hello_lib"],
+)
+```
+
+Run the test with `bazel build //hello_lib:hello_lib_test`.
+
+To run a crate or lib with the `#[cfg(test)]` configuration, handling inline         tests, you should specify the crate directly like so.
+
+```python
+rust_test(
+    name = "hello_lib_test",
+    crate = ":hello_lib",
+    # You may add other deps that are specific to the test configuration
+    deps = ["//some/dev/dep"],
+)
+```
+
+### Example: `test` directory
+
+Integration tests that live in the [`tests` directory][int-tests], they are         essentially built as separate crates. Suppose you have the following directory         structure where `greeting.rs` is an integration test for the `hello_lib`         library crate:
+
+[int-tests]: http://doc.rust-lang.org/book/testing.html#the-tests-directory
+
+```output
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+        tests/
+            greeting.rs
+```
+
+`hello_lib/tests/greeting.rs`:
+```rust
+extern crate hello_lib;
+
+use hello_lib;
+
+#[test]
+fn test_greeting() {
+    let hello = greeter::Greeter::new("Hello");
+    assert_eq!("Hello world", hello.greeting("world"));
+}
+```
+
+To build the `greeting.rs` integration test, simply add a `rust_test` target
+with `greeting.rs` in `srcs` and a dependency on the `hello_lib` target:
+
+`hello_lib/BUILD`:
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Run the test with `bazel build //hello_lib:hello_lib_test`.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_test-aliases"></a>aliases |  Remap crates to a new name or moniker for linkage to this target<br><br>These are other <code>rust_library</code> targets and will be presented as the new name given.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: Label -> String</a> | optional | {} |
+| <a id="rust_test-compile_data"></a>compile_data |  List of files used by this rule at compile time.<br><br>This attribute can be used to specify any data files that are embedded into the library, such as via the [<code>include_str!</code>](https://doc.rust-lang.org/std/macro.include_str!.html) macro.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-crate"></a>crate |  Target inline tests declared in the given crate<br><br>These tests are typically those that would be held out under <code>#[cfg(test)]</code> declarations.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_test-crate_features"></a>crate_features |  List of features to enable for this crate.<br><br>Features are defined in the code using the <code>#[cfg(feature = "foo")]</code> configuration option. The features listed here will be passed to <code>rustc</code> with <code>--cfg feature="${feature_name}"</code> flags.   | List of strings | optional | [] |
+| <a id="rust_test-crate_name"></a>crate_name |  Crate name to use for this target.<br><br>This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores.   | String | optional | "" |
+| <a id="rust_test-crate_root"></a>crate_root |  The file that will be passed to <code>rustc</code> to be used for building this crate.<br><br>If <code>crate_root</code> is not set, then this rule will look for a <code>lib.rs</code> file (or <code>main.rs</code> for rust_binary) or the single file in <code>srcs</code> if <code>srcs</code> contains only one file.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_test-data"></a>data |  List of files used by this rule at compile time and runtime.<br><br>If including data at compile time with include_str!() and similar, prefer <code>compile_data</code> over <code>data</code>, to prevent the data also being included in the runfiles.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-deps"></a>deps |  List of other libraries to be linked to this library target.<br><br>These can be either other <code>rust_library</code> targets or <code>cc_library</code> targets if linking a native library.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-edition"></a>edition |  The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.   | String | optional | "" |
+| <a id="rust_test-env"></a>env |  Specifies additional environment variables to set when the test is executed by bazel test. Values are subject to <code>$(rootpath)</code>, <code>$(execpath)</code>, location, and ["Make variable"](https://docs.bazel.build/versions/master/be/make-variables.html) substitution.<br><br>Execpath returns absolute path, and in order to be able to construct the absolute path we need to wrap the test binary in a launcher. Using a launcher comes with complications, such as more complicated debugger attachment.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_test-proc_macro_deps"></a>proc_macro_deps |  List of <code>rust_library</code> targets with kind <code>proc-macro</code> used to help build this library target.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-rustc_env"></a>rustc_env |  Dictionary of additional <code>"key": "value"</code> environment variables to set for rustc.<br><br>rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_test-rustc_env_files"></a>rustc_env_files |  Files containing additional environment variables to set for rustc.<br><br>These files should  contain a single variable per line, of format <code>NAME=value</code>, and newlines may be included in a value by ending a line with a trailing back-slash (<code>\\</code>).<br><br>The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged.<br><br>Note that the variables here are subject to [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status) stamping should the <code>stamp</code> attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. <code>NAME={WORKSPACE_STATUS_VARIABLE}</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.<br><br>These strings are subject to Make variable expansion for predefined source/output path variables like <code>$location</code>, <code>$execpath</code>, and <code>$rootpath</code>. This expansion is useful if you wish to pass a generated file of arguments to rustc: <code>@$(location //package:target)</code>.   | List of strings | optional | [] |
+| <a id="rust_test-srcs"></a>srcs |  List of Rust <code>.rs</code> source files used to build the library.<br><br>If <code>srcs</code> contains more than one file, then there must be a file either named <code>lib.rs</code>. Otherwise, <code>crate_root</code> must be set to the source file that is the root of the crate to be passed to rustc to build this crate.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+| <a id="rust_test-stamp"></a>stamp |  Whether to encode build information into the <code>Rustc</code> action. Possible values:<br><br>- <code>stamp = 1</code>: Always stamp the build information into the <code>Rustc</code> action, even in             [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds.             This setting should be avoided, since it potentially kills remote caching for the target and             any downstream actions that depend on it.<br><br>- <code>stamp = 0</code>: Always replace build information by constant values. This gives good build result caching.<br><br>- <code>stamp = -1</code>: Embedding of build information is controlled by the             [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.<br><br>Stamped targets are not rebuilt unless their dependencies change.<br><br>For example if a <code>rust_library</code> is stamped, and a <code>rust_binary</code> depends on that library, the stamped library won't be rebuilt when we change sources of the <code>rust_binary</code>. This is different from how [<code>cc_library.linkstamps</code>](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) behaves.   | Integer | optional | -1 |
+| <a id="rust_test-use_libtest_harness"></a>use_libtest_harness |  Whether to use <code>libtest</code>. For targets using this flag, individual tests can be run by using the [--test_arg](https://docs.bazel.build/versions/4.0.0/command-line-reference.html#flag--test_arg) flag. E.g. <code>bazel test //src:rust_test --test_arg=foo::test::test_fn</code>.   | Boolean | optional | True |
+| <a id="rust_test-version"></a>version |  A version to inject in the cargo environment variable.   | String | optional | "0.0.0" |
+
+
+<a id="#rust_toolchain"></a>
+
+## rust_toolchain
+
+<pre>
+rust_toolchain(<a href="#rust_toolchain-name">name</a>, <a href="#rust_toolchain-allocator_library">allocator_library</a>, <a href="#rust_toolchain-binary_ext">binary_ext</a>, <a href="#rust_toolchain-cargo">cargo</a>, <a href="#rust_toolchain-clippy_driver">clippy_driver</a>, <a href="#rust_toolchain-debug_info">debug_info</a>,
+               <a href="#rust_toolchain-default_edition">default_edition</a>, <a href="#rust_toolchain-dylib_ext">dylib_ext</a>, <a href="#rust_toolchain-exec_triple">exec_triple</a>, <a href="#rust_toolchain-llvm_tools">llvm_tools</a>, <a href="#rust_toolchain-opt_level">opt_level</a>, <a href="#rust_toolchain-os">os</a>, <a href="#rust_toolchain-rust_doc">rust_doc</a>, <a href="#rust_toolchain-rust_lib">rust_lib</a>,
+               <a href="#rust_toolchain-rust_std">rust_std</a>, <a href="#rust_toolchain-rustc">rustc</a>, <a href="#rust_toolchain-rustc_lib">rustc_lib</a>, <a href="#rust_toolchain-rustc_srcs">rustc_srcs</a>, <a href="#rust_toolchain-rustfmt">rustfmt</a>, <a href="#rust_toolchain-staticlib_ext">staticlib_ext</a>, <a href="#rust_toolchain-stdlib_linkflags">stdlib_linkflags</a>,
+               <a href="#rust_toolchain-target_json">target_json</a>, <a href="#rust_toolchain-target_triple">target_triple</a>)
+</pre>
+
+Declares a Rust toolchain for use.
+
+This is for declaring a custom toolchain, eg. for configuring a particular version of rust or supporting a new platform.
+
+Example:
+
+Suppose the core rust team has ported the compiler to a new target CPU, called `cpuX`. This support can be used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//rust:toolchain.bzl', 'rust_toolchain')
+
+rust_toolchain(
+    name = "rust_cpuX_impl",
+    rustc = "@rust_cpuX//:rustc",
+    rustc_lib = "@rust_cpuX//:rustc_lib",
+    rust_std = "@rust_cpuX//:rust_std",
+    rust_doc = "@rust_cpuX//:rustdoc",
+    binary_ext = "",
+    staticlib_ext = ".a",
+    dylib_ext = ".so",
+    stdlib_linkflags = ["-lpthread", "-ldl"],
+    os = "linux",
+)
+
+toolchain(
+    name = "rust_cpuX",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_cpuX_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to `register_toolchains` in the WORKSPACE, or pass it to the `"--extra_toolchains"` flag for Bazel, and it will be used.
+
+See @rules_rust//rust:repositories.bzl for examples of defining the @rust_cpuX repository with the actual binaries and libraries.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain-allocator_library"></a>allocator_library |  Target that provides allocator functions when rust_library targets are embedded in a cc_binary.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-binary_ext"></a>binary_ext |  The extension for binaries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-cargo"></a>cargo |  The location of the <code>cargo</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-clippy_driver"></a>clippy_driver |  The location of the <code>clippy-driver</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-debug_info"></a>debug_info |  Rustc debug info levels per opt level   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {"dbg": "2", "fastbuild": "0", "opt": "0"} |
+| <a id="rust_toolchain-default_edition"></a>default_edition |  The edition to use for rust_* rules that don't specify an edition.   | String | optional | "2018" |
+| <a id="rust_toolchain-dylib_ext"></a>dylib_ext |  The extension for dynamic libraries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-exec_triple"></a>exec_triple |  The platform triple for the toolchains execution environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations   | String | required |  |
+| <a id="rust_toolchain-llvm_tools"></a>llvm_tools |  LLVM tools that are shipped with the Rust toolchain.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-opt_level"></a>opt_level |  Rustc optimization levels.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {"dbg": "0", "fastbuild": "0", "opt": "3"} |
+| <a id="rust_toolchain-os"></a>os |  The operating system for the current toolchain   | String | required |  |
+| <a id="rust_toolchain-rust_doc"></a>rust_doc |  The location of the <code>rustdoc</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_toolchain-rust_lib"></a>rust_lib |  **Deprecated**: Use <code>rust_std</code>   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rust_std"></a>rust_std |  The Rust standard library.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustc"></a>rustc |  The location of the <code>rustc</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_toolchain-rustc_lib"></a>rustc_lib |  The libraries used by rustc during compilation.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustc_srcs"></a>rustc_srcs |  The source code of rustc.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustfmt"></a>rustfmt |  The location of the <code>rustfmt</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-staticlib_ext"></a>staticlib_ext |  The extension for static libraries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-stdlib_linkflags"></a>stdlib_linkflags |  Additional linker flags to use when Rust standard library is linked by a C++ linker (rustc will deal with these automatically). Subject to location expansion with respect to the srcs of the <code>rust_std</code> attribute.   | List of strings | required |  |
+| <a id="rust_toolchain-target_json"></a>target_json |  Override the target_triple with a custom target specification. For more details see: https://doc.rust-lang.org/rustc/targets/custom.html   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-target_triple"></a>target_triple |  The platform triple for the toolchains target environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations   | String | optional | "" |
+
+
+<a id="#rust_toolchain_repository"></a>
+
+## rust_toolchain_repository
+
+<pre>
+rust_toolchain_repository(<a href="#rust_toolchain_repository-name">name</a>, <a href="#rust_toolchain_repository-auth">auth</a>, <a href="#rust_toolchain_repository-dev_components">dev_components</a>, <a href="#rust_toolchain_repository-edition">edition</a>, <a href="#rust_toolchain_repository-exec_triple">exec_triple</a>, <a href="#rust_toolchain_repository-extra_target_triples">extra_target_triples</a>,
+                          <a href="#rust_toolchain_repository-include_rustc_srcs">include_rustc_srcs</a>, <a href="#rust_toolchain_repository-iso_date">iso_date</a>, <a href="#rust_toolchain_repository-repo_mapping">repo_mapping</a>, <a href="#rust_toolchain_repository-rustfmt_version">rustfmt_version</a>, <a href="#rust_toolchain_repository-sha256s">sha256s</a>,
+                          <a href="#rust_toolchain_repository-toolchain_name_prefix">toolchain_name_prefix</a>, <a href="#rust_toolchain_repository-urls">urls</a>, <a href="#rust_toolchain_repository-version">version</a>)
+</pre>
+
+Composes a single workspace containing the toolchain components for compiling on a given platform to a series of target platforms.
+
+A given instance of this rule should be accompanied by a rust_toolchain_repository_proxy invocation to declare its toolchains to Bazel; the indirection allows separating toolchain selection from toolchain fetching.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain_repository-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain_repository-auth"></a>auth |  Auth object compatible with repository_ctx.download to use when downloading files. See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_toolchain_repository-dev_components"></a>dev_components |  Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly".   | Boolean | optional | False |
+| <a id="rust_toolchain_repository-edition"></a>edition |  The rust edition to be used by default.   | String | optional | "2018" |
+| <a id="rust_toolchain_repository-exec_triple"></a>exec_triple |  The Rust-style target that this compiler runs on   | String | required |  |
+| <a id="rust_toolchain_repository-extra_target_triples"></a>extra_target_triples |  Additional rust-style targets that this set of toolchains should support.   | List of strings | optional | [] |
+| <a id="rust_toolchain_repository-include_rustc_srcs"></a>include_rustc_srcs |  Whether to download and unpack the rustc source files. These are very large, and slow to unpack, but are required to support rust analyzer. An environment variable <code>RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS</code> can also be used to control this attribute. This variable will take precedence over the hard coded attribute. Setting it to <code>true</code> to activates this attribute where all other values deactivate it.   | Boolean | optional | False |
+| <a id="rust_toolchain_repository-iso_date"></a>iso_date |  The date of the tool (or None, if the version is a specific version).   | String | optional | "" |
+| <a id="rust_toolchain_repository-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="rust_toolchain_repository-rustfmt_version"></a>rustfmt_version |  The version of the tool among "nightly", "beta", or an exact version.   | String | optional | "" |
+| <a id="rust_toolchain_repository-sha256s"></a>sha256s |  A dict associating tool subdirectories to sha256 hashes. See [rust_repositories](#rust_repositories) for more details.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_toolchain_repository-toolchain_name_prefix"></a>toolchain_name_prefix |  The per-target prefix expected for the rust_toolchain declarations in the parent workspace.   | String | optional | "" |
+| <a id="rust_toolchain_repository-urls"></a>urls |  A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format).   | List of strings | optional | ["https://static.rust-lang.org/dist/{}.tar.gz"] |
+| <a id="rust_toolchain_repository-version"></a>version |  The version of the tool among "nightly", "beta", or an exact version.   | String | required |  |
+
+
+<a id="#rust_toolchain_repository_proxy"></a>
+
+## rust_toolchain_repository_proxy
+
+<pre>
+rust_toolchain_repository_proxy(<a href="#rust_toolchain_repository_proxy-name">name</a>, <a href="#rust_toolchain_repository_proxy-exec_triple">exec_triple</a>, <a href="#rust_toolchain_repository_proxy-extra_target_triples">extra_target_triples</a>, <a href="#rust_toolchain_repository_proxy-parent_workspace_name">parent_workspace_name</a>,
+                                <a href="#rust_toolchain_repository_proxy-repo_mapping">repo_mapping</a>, <a href="#rust_toolchain_repository_proxy-toolchain_name_prefix">toolchain_name_prefix</a>)
+</pre>
+
+Generates a toolchain-bearing repository that declares the toolchains from some other rust_toolchain_repository.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain_repository_proxy-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain_repository_proxy-exec_triple"></a>exec_triple |  The Rust-style target triple for the compilation platform   | String | required |  |
+| <a id="rust_toolchain_repository_proxy-extra_target_triples"></a>extra_target_triples |  The Rust-style triples for extra compilation targets   | List of strings | optional | [] |
+| <a id="rust_toolchain_repository_proxy-parent_workspace_name"></a>parent_workspace_name |  The name of the other rust_toolchain_repository   | String | required |  |
+| <a id="rust_toolchain_repository_proxy-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="rust_toolchain_repository_proxy-toolchain_name_prefix"></a>toolchain_name_prefix |  The per-target prefix expected for the rust_toolchain declarations in the parent workspace.   | String | optional | "" |
+
+
+<a id="#rust_wasm_bindgen"></a>
+
+## rust_wasm_bindgen
+
+<pre>
+rust_wasm_bindgen(<a href="#rust_wasm_bindgen-name">name</a>, <a href="#rust_wasm_bindgen-bindgen_flags">bindgen_flags</a>, <a href="#rust_wasm_bindgen-target">target</a>, <a href="#rust_wasm_bindgen-wasm_file">wasm_file</a>)
+</pre>
+
+Generates javascript and typescript bindings for a webassembly module using [wasm-bindgen][ws].
+
+[ws]: https://rustwasm.github.io/docs/wasm-bindgen/
+
+To use the Rust WebAssembly bindgen rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust bindgen toolchain (in addition to the Rust rules setup):
+
+```python
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+```
+
+For more details on `rust_wasm_bindgen_repositories`, see [here](#rust_wasm_bindgen_repositories).
+
+An example of this rule in use can be seen at [@rules_rust//examples/wasm](../examples/wasm)
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_wasm_bindgen-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://github.com/rustwasm/wasm-bindgen/ for details.   | List of strings | optional | [] |
+| <a id="rust_wasm_bindgen-target"></a>target |  The type of output to generate. See https://rustwasm.github.io/wasm-bindgen/reference/deployment.html for details.   | String | optional | "bundler" |
+| <a id="rust_wasm_bindgen-wasm_file"></a>wasm_file |  The <code>.wasm</code> file or crate to generate bindings for.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+
+
+<a id="#rust_wasm_bindgen_toolchain"></a>
+
+## rust_wasm_bindgen_toolchain
+
+<pre>
+rust_wasm_bindgen_toolchain(<a href="#rust_wasm_bindgen_toolchain-name">name</a>, <a href="#rust_wasm_bindgen_toolchain-bindgen">bindgen</a>)
+</pre>
+
+The tools required for the `rust_wasm_bindgen` rule.
+
+In cases where users want to control or change the version of `wasm-bindgen` used by [rust_wasm_bindgen](#rust_wasm_bindgen),
+a unique toolchain can be created as in the example below:
+
+```python
+load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_toolchain")
+
+rust_bindgen_toolchain(
+    bindgen = "//my/cargo_raze:cargo_bin_wasm_bindgen",
+)
+
+toolchain(
+    name = "wasm_bindgen_toolchain",
+    toolchain = "wasm_bindgen_toolchain_impl",
+    toolchain_type = "@rules_rust//wasm_bindgen:wasm_bindgen_toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:wasm_bindgen_toolchain")
+```
+
+For additional information, see the [Bazel toolchains documentation][toolchains].
+
+[toolchains]: https://docs.bazel.build/versions/master/toolchains.html
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_wasm_bindgen_toolchain-bindgen"></a>bindgen |  The label of a <code>wasm-bindgen-cli</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+
+
+<a id="#rustfmt_test"></a>
+
+## rustfmt_test
+
+<pre>
+rustfmt_test(<a href="#rustfmt_test-name">name</a>, <a href="#rustfmt_test-targets">targets</a>)
+</pre>
+
+A test rule for performing `rustfmt --check` on a set of targets
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rustfmt_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rustfmt_test-targets"></a>targets |  Rust targets to run <code>rustfmt --check</code> on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#CrateInfo"></a>
+
+## CrateInfo
+
+<pre>
+CrateInfo(<a href="#CrateInfo-aliases">aliases</a>, <a href="#CrateInfo-compile_data">compile_data</a>, <a href="#CrateInfo-deps">deps</a>, <a href="#CrateInfo-edition">edition</a>, <a href="#CrateInfo-is_test">is_test</a>, <a href="#CrateInfo-name">name</a>, <a href="#CrateInfo-output">output</a>, <a href="#CrateInfo-owner">owner</a>, <a href="#CrateInfo-proc_macro_deps">proc_macro_deps</a>, <a href="#CrateInfo-root">root</a>,
+          <a href="#CrateInfo-rustc_env">rustc_env</a>, <a href="#CrateInfo-srcs">srcs</a>, <a href="#CrateInfo-type">type</a>, <a href="#CrateInfo-wrapped_crate_type">wrapped_crate_type</a>)
+</pre>
+
+A provider containing general Crate information.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="CrateInfo-aliases"></a>aliases |  Dict[Label, String]: Renamed and aliased crates    |
+| <a id="CrateInfo-compile_data"></a>compile_data |  depset[File]: Compile data required by this crate.    |
+| <a id="CrateInfo-deps"></a>deps |  depset[DepVariantInfo]: This crate's (rust or cc) dependencies' providers.    |
+| <a id="CrateInfo-edition"></a>edition |  str: The edition of this crate.    |
+| <a id="CrateInfo-is_test"></a>is_test |  bool: If the crate is being compiled in a test context    |
+| <a id="CrateInfo-name"></a>name |  str: The name of this crate.    |
+| <a id="CrateInfo-output"></a>output |  File: The output File that will be produced, depends on crate type.    |
+| <a id="CrateInfo-owner"></a>owner |  Label: The label of the target that produced this CrateInfo    |
+| <a id="CrateInfo-proc_macro_deps"></a>proc_macro_deps |  depset[DepVariantInfo]: This crate's rust proc_macro dependencies' providers.    |
+| <a id="CrateInfo-root"></a>root |  File: The source File entrypoint to this crate, eg. lib.rs    |
+| <a id="CrateInfo-rustc_env"></a>rustc_env |  Dict[String, String]: Additional <code>"key": "value"</code> environment variables to set for rustc.    |
+| <a id="CrateInfo-srcs"></a>srcs |  depset[File]: All source Files that are part of the crate.    |
+| <a id="CrateInfo-type"></a>type |  str: The type of this crate (see [rustc --crate-type](https://doc.rust-lang.org/rustc/command-line-arguments.html#--crate-type-a-list-of-types-of-crates-for-the-compiler-to-emit)).    |
+| <a id="CrateInfo-wrapped_crate_type"></a>wrapped_crate_type |  str, optional: The original crate type for targets generated using a previously defined crate (typically tests using the <code>rust_test::crate</code> attribute)    |
+
+
+<a id="#DepInfo"></a>
+
+## DepInfo
+
+<pre>
+DepInfo(<a href="#DepInfo-dep_env">dep_env</a>, <a href="#DepInfo-direct_crates">direct_crates</a>, <a href="#DepInfo-link_search_path_files">link_search_path_files</a>, <a href="#DepInfo-transitive_build_infos">transitive_build_infos</a>,
+        <a href="#DepInfo-transitive_crate_outputs">transitive_crate_outputs</a>, <a href="#DepInfo-transitive_crates">transitive_crates</a>, <a href="#DepInfo-transitive_noncrates">transitive_noncrates</a>)
+</pre>
+
+A provider containing information about a Crate's dependencies.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="DepInfo-dep_env"></a>dep_env |  File: File with environment variables direct dependencies build scripts rely upon.    |
+| <a id="DepInfo-direct_crates"></a>direct_crates |  depset[AliasableDepInfo]    |
+| <a id="DepInfo-link_search_path_files"></a>link_search_path_files |  depset[File]: All transitive files containing search paths to pass to the linker    |
+| <a id="DepInfo-transitive_build_infos"></a>transitive_build_infos |  depset[BuildInfo]    |
+| <a id="DepInfo-transitive_crate_outputs"></a>transitive_crate_outputs |  depset[File]: All transitive crate outputs.    |
+| <a id="DepInfo-transitive_crates"></a>transitive_crates |  depset[CrateInfo]    |
+| <a id="DepInfo-transitive_noncrates"></a>transitive_noncrates |  depset[LinkerInput]: All transitive dependencies that aren't crates.    |
+
+
+<a id="#StdLibInfo"></a>
+
+## StdLibInfo
+
+<pre>
+StdLibInfo(<a href="#StdLibInfo-alloc_files">alloc_files</a>, <a href="#StdLibInfo-between_alloc_and_core_files">between_alloc_and_core_files</a>, <a href="#StdLibInfo-between_core_and_std_files">between_core_and_std_files</a>, <a href="#StdLibInfo-core_files">core_files</a>,
+           <a href="#StdLibInfo-dot_a_files">dot_a_files</a>, <a href="#StdLibInfo-self_contained_files">self_contained_files</a>, <a href="#StdLibInfo-srcs">srcs</a>, <a href="#StdLibInfo-std_files">std_files</a>, <a href="#StdLibInfo-std_rlibs">std_rlibs</a>)
+</pre>
+
+A collection of files either found within the `rust-stdlib` artifact or generated based on existing files.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="StdLibInfo-alloc_files"></a>alloc_files |  List[File]: <code>.a</code> files related to the <code>alloc</code> module.    |
+| <a id="StdLibInfo-between_alloc_and_core_files"></a>between_alloc_and_core_files |  List[File]: <code>.a</code> files related to the <code>compiler_builtins</code> module.    |
+| <a id="StdLibInfo-between_core_and_std_files"></a>between_core_and_std_files |  List[File]: <code>.a</code> files related to all modules except <code>adler</code>, <code>alloc</code>, <code>compiler_builtins</code>, <code>core</code>, and <code>std</code>.    |
+| <a id="StdLibInfo-core_files"></a>core_files |  List[File]: <code>.a</code> files related to the <code>core</code> and <code>adler</code> modules    |
+| <a id="StdLibInfo-dot_a_files"></a>dot_a_files |  Depset[File]: Generated <code>.a</code> files    |
+| <a id="StdLibInfo-self_contained_files"></a>self_contained_files |  List[File]: All <code>.o</code> files from the <code>self-contained</code> directory.    |
+| <a id="StdLibInfo-srcs"></a>srcs |  List[Target]: All targets from the original <code>srcs</code> attribute.    |
+| <a id="StdLibInfo-std_files"></a>std_files |  Depset[File]: <code>.a</code> files associated with the <code>std</code> module.    |
+| <a id="StdLibInfo-std_rlibs"></a>std_rlibs |  List[File]: All <code>.rlib</code> files    |
+
+
+<a id="#cargo_build_script"></a>
+
+## cargo_build_script
+
+<pre>
+cargo_build_script(<a href="#cargo_build_script-name">name</a>, <a href="#cargo_build_script-crate_features">crate_features</a>, <a href="#cargo_build_script-version">version</a>, <a href="#cargo_build_script-deps">deps</a>, <a href="#cargo_build_script-build_script_env">build_script_env</a>, <a href="#cargo_build_script-data">data</a>, <a href="#cargo_build_script-tools">tools</a>, <a href="#cargo_build_script-links">links</a>,
+                   <a href="#cargo_build_script-rustc_env">rustc_env</a>, <a href="#cargo_build_script-rustc_flags">rustc_flags</a>, <a href="#cargo_build_script-visibility">visibility</a>, <a href="#cargo_build_script-tags">tags</a>, <a href="#cargo_build_script-kwargs">kwargs</a>)
+</pre>
+
+Compile and execute a rust build script to generate build attributes
+
+This rules take the same arguments as rust_binary.
+
+Example:
+
+Suppose you have a crate with a cargo build script `build.rs`:
+
+```output
+[workspace]/
+    hello_lib/
+        BUILD
+        build.rs
+        src/
+            lib.rs
+```
+
+Then you want to use the build script in the following:
+
+`hello_lib/BUILD`:
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
+load("@rules_rust//cargo:cargo_build_script.bzl", "cargo_build_script")
+
+# This will run the build script from the root of the workspace, and
+# collect the outputs.
+cargo_build_script(
+    name = "build_script",
+    srcs = ["build.rs"],
+    # Optional environment variables passed during build.rs compilation
+    rustc_env = {
+       "CARGO_PKG_VERSION": "0.1.2",
+    },
+    # Optional environment variables passed during build.rs execution.
+    # Note that as the build script's working directory is not execroot,
+    # execpath/location will return an absolute path, instead of a relative
+    # one.
+    build_script_env = {
+        "SOME_TOOL_OR_FILE": "$(execpath @tool//:binary)"
+    }
+    # Optional data/tool dependencies
+    data = ["@tool//:binary"],
+)
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/lib.rs",
+    ],
+    deps = [":build_script"],
+)
+```
+
+The `hello_lib` target will be build with the flags and the environment variables declared by the     build script in addition to the file generated by it.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="cargo_build_script-name"></a>name |  The name for the underlying rule. This should be the name of the package being compiled, optionally with a suffix of _build_script.   |  none |
+| <a id="cargo_build_script-crate_features"></a>crate_features |  A list of features to enable for the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-version"></a>version |  The semantic version (semver) of the crate.   |  <code>None</code> |
+| <a id="cargo_build_script-deps"></a>deps |  The dependencies of the crate.   |  <code>[]</code> |
+| <a id="cargo_build_script-build_script_env"></a>build_script_env |  Environment variables for build scripts.   |  <code>{}</code> |
+| <a id="cargo_build_script-data"></a>data |  Files needed by the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-tools"></a>tools |  Tools (executables) needed by the build script.   |  <code>[]</code> |
+| <a id="cargo_build_script-links"></a>links |  Name of the native library this crate links against.   |  <code>None</code> |
+| <a id="cargo_build_script-rustc_env"></a>rustc_env |  Environment variables to set in rustc when compiling the build script.   |  <code>{}</code> |
+| <a id="cargo_build_script-rustc_flags"></a>rustc_flags |  List of compiler flags passed to <code>rustc</code>.   |  <code>[]</code> |
+| <a id="cargo_build_script-visibility"></a>visibility |  Visibility to apply to the generated build script output.   |  <code>None</code> |
+| <a id="cargo_build_script-tags"></a>tags |  (list of str, optional): Tags to apply to the generated build script output.   |  <code>None</code> |
+| <a id="cargo_build_script-kwargs"></a>kwargs |  Forwards to the underlying <code>rust_binary</code> rule.   |  none |
+
+
+<a id="#cargo_env"></a>
+
+## cargo_env
+
+<pre>
+cargo_env(<a href="#cargo_env-env">env</a>)
+</pre>
+
+A helper for generating platform specific environment variables
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_common")
+load("@rules_rust//cargo:defs.bzl", "cargo_bootstrap_repository", "cargo_env")
+
+cargo_bootstrap_repository(
+    name = "bootstrapped_bin",
+    cargo_lockfile = "//:Cargo.lock",
+    cargo_toml = "//:Cargo.toml",
+    srcs = ["//:resolver_srcs"],
+    version = rust_common.default_version,
+    binary = "my-crate-binary",
+    env = {
+        "x86_64-unknown-linux-gnu": cargo_env({
+            "FOO": "BAR",
+        }),
+    },
+    env_label = {
+        "aarch64-unknown-linux-musl": cargo_env({
+            "DOC": "//:README.md",
+        }),
+    }
+)
+```
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="cargo_env-env"></a>env |  A map of environment variables   |  none |
+
+**RETURNS**
+
+str: A json encoded string of the environment variables
+
+
+<a id="#rust_bindgen_library"></a>
+
+## rust_bindgen_library
+
+<pre>
+rust_bindgen_library(<a href="#rust_bindgen_library-name">name</a>, <a href="#rust_bindgen_library-header">header</a>, <a href="#rust_bindgen_library-cc_lib">cc_lib</a>, <a href="#rust_bindgen_library-bindgen_flags">bindgen_flags</a>, <a href="#rust_bindgen_library-clang_flags">clang_flags</a>, <a href="#rust_bindgen_library-rustfmt">rustfmt</a>, <a href="#rust_bindgen_library-kwargs">kwargs</a>)
+</pre>
+
+Generates a rust source file for `header`, and builds a rust_library.
+
+Arguments are the same as `rust_bindgen`, and `kwargs` are passed directly to rust_library.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_bindgen_library-name"></a>name |  A unique name for this target.   |  none |
+| <a id="rust_bindgen_library-header"></a>header |  The label of the .h file to generate bindings for.   |  none |
+| <a id="rust_bindgen_library-cc_lib"></a>cc_lib |  The label of the cc_library that contains the .h file. This is used to find the transitive includes.   |  none |
+| <a id="rust_bindgen_library-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.   |  <code>None</code> |
+| <a id="rust_bindgen_library-clang_flags"></a>clang_flags |  Flags to pass directly to the clang executable.   |  <code>None</code> |
+| <a id="rust_bindgen_library-rustfmt"></a>rustfmt |  Enable or disable running rustfmt on the generated file.   |  <code>True</code> |
+| <a id="rust_bindgen_library-kwargs"></a>kwargs |  Arguments to forward to the underlying <code>rust_library</code> rule.   |  none |
+
+
+<a id="#rust_bindgen_repositories"></a>
+
+## rust_bindgen_repositories
+
+<pre>
+rust_bindgen_repositories()
+</pre>
+
+Declare dependencies needed for bindgen.
+
+
+
+<a id="#rust_proto_repositories"></a>
+
+## rust_proto_repositories
+
+<pre>
+rust_proto_repositories(<a href="#rust_proto_repositories-register_default_toolchain">register_default_toolchain</a>)
+</pre>
+
+Declare dependencies needed for proto compilation.
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_proto_repositories-register_default_toolchain"></a>register_default_toolchain |  If True, the default [rust_proto_toolchain](#rust_proto_toolchain) (<code>@rules_rust//proto:default-proto-toolchain</code>) is registered. This toolchain requires a set of dependencies that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.   |  <code>True</code> |
+
+
+<a id="#rust_proto_transitive_repositories"></a>
+
+## rust_proto_transitive_repositories
+
+<pre>
+rust_proto_transitive_repositories()
+</pre>
+
+Load transitive dependencies of the `@rules_rust//proto` rules.
+
+This macro should be called immediately after the `rust_proto_repositories` macro.
+
+
+
+<a id="#rust_repositories"></a>
+
+## rust_repositories
+
+<pre>
+rust_repositories(<a href="#rust_repositories-kwargs">kwargs</a>)
+</pre>
+
+**Deprecated**: Use [rules_rust_dependencies](#rules_rust_dependencies)     and [rust_register_toolchains](#rust_register_toolchains) directly.
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_repositories-kwargs"></a>kwargs |  Keyword arguments for the <code>rust_register_toolchains</code> macro.   |  none |
+
+
+<a id="#rust_repository_set"></a>
+
+## rust_repository_set
+
+<pre>
+rust_repository_set(<a href="#rust_repository_set-name">name</a>, <a href="#rust_repository_set-version">version</a>, <a href="#rust_repository_set-exec_triple">exec_triple</a>, <a href="#rust_repository_set-include_rustc_srcs">include_rustc_srcs</a>, <a href="#rust_repository_set-extra_target_triples">extra_target_triples</a>, <a href="#rust_repository_set-iso_date">iso_date</a>,
+                    <a href="#rust_repository_set-rustfmt_version">rustfmt_version</a>, <a href="#rust_repository_set-edition">edition</a>, <a href="#rust_repository_set-dev_components">dev_components</a>, <a href="#rust_repository_set-sha256s">sha256s</a>, <a href="#rust_repository_set-urls">urls</a>, <a href="#rust_repository_set-auth">auth</a>, <a href="#rust_repository_set-register_toolchain">register_toolchain</a>)
+</pre>
+
+Assembles a remote repository for the given toolchain params, produces a proxy repository     to contain the toolchain declaration, and registers the toolchains.
+
+N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints)     without actually downloading the toolchain.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_repository_set-name"></a>name |  The name of the generated repository   |  none |
+| <a id="rust_repository_set-version"></a>version |  The version of the tool among "nightly", "beta', or an exact version.   |  none |
+| <a id="rust_repository_set-exec_triple"></a>exec_triple |  The Rust-style target that this compiler runs on   |  none |
+| <a id="rust_repository_set-include_rustc_srcs"></a>include_rustc_srcs |  Whether to download rustc's src code. This is required in order to use rust-analyzer support. Defaults to False.   |  <code>False</code> |
+| <a id="rust_repository_set-extra_target_triples"></a>extra_target_triples |  Additional rust-style targets that this set of toolchains should support. Defaults to [].   |  <code>[]</code> |
+| <a id="rust_repository_set-iso_date"></a>iso_date |  The date of the tool. Defaults to None.   |  <code>None</code> |
+| <a id="rust_repository_set-rustfmt_version"></a>rustfmt_version |  The version of rustfmt to be associated with the toolchain. Defaults to None.   |  <code>None</code> |
+| <a id="rust_repository_set-edition"></a>edition |  The rust edition to be used by default (2015, 2018 (if None), or 2021).   |  <code>None</code> |
+| <a id="rust_repository_set-dev_components"></a>dev_components |  Whether to download the rustc-dev components. Requires version to be "nightly". Defaults to False.   |  <code>False</code> |
+| <a id="rust_repository_set-sha256s"></a>sha256s |  A dict associating tool subdirectories to sha256 hashes. See [rust_repositories](#rust_repositories) for more details.   |  <code>None</code> |
+| <a id="rust_repository_set-urls"></a>urls |  A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). Defaults to ['https://static.rust-lang.org/dist/{}.tar.gz']   |  <code>["https://static.rust-lang.org/dist/{}.tar.gz"]</code> |
+| <a id="rust_repository_set-auth"></a>auth |  Auth object compatible with repository_ctx.download to use when downloading files. See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details.   |  <code>None</code> |
+| <a id="rust_repository_set-register_toolchain"></a>register_toolchain |  If True, the generated <code>rust_toolchain</code> target will become a registered toolchain.   |  <code>True</code> |
+
+
+<a id="#rust_test_suite"></a>
+
+## rust_test_suite
+
+<pre>
+rust_test_suite(<a href="#rust_test_suite-name">name</a>, <a href="#rust_test_suite-srcs">srcs</a>, <a href="#rust_test_suite-kwargs">kwargs</a>)
+</pre>
+
+A rule for creating a test suite for a set of `rust_test` targets.
+
+This rule can be used for setting up typical rust [integration tests][it]. Given the following
+directory structure:
+
+```text
+[crate]/
+    BUILD.bazel
+    src/
+        lib.rs
+        main.rs
+    tests/
+        integrated_test_a.rs
+        integrated_test_b.rs
+        integrated_test_c.rs
+        patterns/
+            fibonacci_test.rs
+```
+
+The rule can be used to generate [rust_test](#rust_test) targets for each source file under `tests`
+and a [test_suite][ts] which encapsulates all tests.
+
+```python
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test_suite")
+
+rust_library(
+    name = "math_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_binary(
+    name = "math_bin",
+    srcs = ["src/main.rs"],
+)
+
+rust_test_suite(
+    name = "integrated_tests_suite",
+    srcs = glob(["tests/**"]),
+    deps = [":math_lib"],
+)
+```
+
+[it]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
+[ts]: https://docs.bazel.build/versions/master/be/general.html#test_suite
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_test_suite-name"></a>name |  The name of the <code>test_suite</code>.   |  none |
+| <a id="rust_test_suite-srcs"></a>srcs |  All test sources, typically <code>glob(["tests/**/*.rs"])</code>.   |  none |
+| <a id="rust_test_suite-kwargs"></a>kwargs |  Additional keyword arguments for the underyling [rust_test](#rust_test) targets. The <code>tags</code> argument is also passed to the generated <code>test_suite</code> target.   |  none |
+
+
+<a id="#rust_wasm_bindgen_repositories"></a>
+
+## rust_wasm_bindgen_repositories
+
+<pre>
+rust_wasm_bindgen_repositories(<a href="#rust_wasm_bindgen_repositories-register_default_toolchain">register_default_toolchain</a>)
+</pre>
+
+Declare dependencies needed for [rust_wasm_bindgen](#rust_wasm_bindgen).
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen_repositories-register_default_toolchain"></a>register_default_toolchain |  If True, the default [rust_wasm_bindgen_toolchain](#rust_wasm_bindgen_toolchain) (<code>@rules_rust//wasm_bindgen:default_wasm_bindgen_toolchain</code>) is registered. This toolchain requires a set of dependencies that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.   |  <code>True</code> |
+
+
+<a id="#rust_analyzer_aspect"></a>
+
+## rust_analyzer_aspect
+
+<pre>
+rust_analyzer_aspect(<a href="#rust_analyzer_aspect-name">name</a>)
+</pre>
+
+Annotates rust rules with RustAnalyzerInfo later used to build a rust-project.json
+
+**ASPECT ATTRIBUTES**
+
+
+| Name | Type |
+| :------------- | :------------- |
+| deps| String |
+| proc_macro_deps| String |
+| crate| String |
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_analyzer_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
+<a id="#rust_clippy_aspect"></a>
+
+## rust_clippy_aspect
+
+<pre>
+rust_clippy_aspect(<a href="#rust_clippy_aspect-name">name</a>)
+</pre>
+
+Executes the clippy checker on specified targets.
+
+This aspect applies to existing rust_library, rust_test, and rust_binary rules.
+
+As an example, if the following is defined in `examples/hello_lib/BUILD.bazel`:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Then the targets can be analyzed with clippy using the following command:
+
+```output
+$ bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect               --output_groups=clippy_checks //hello_lib:all
+```
+
+
+**ASPECT ATTRIBUTES**
+
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_clippy_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
+<a id="#rustfmt_aspect"></a>
+
+## rustfmt_aspect
+
+<pre>
+rustfmt_aspect(<a href="#rustfmt_aspect-name">name</a>)
+</pre>
+
+This aspect is used to gather information about a crate for use in rustfmt and perform rustfmt checks
+
+Output Groups:
+
+- `rustfmt_manifest`: A manifest used by rustfmt binaries to provide crate specific settings.
+- `rustfmt_checks`: Executes `rustfmt --check` on the specified target.
+
+The build setting `@rules_rust//:rustfmt.toml` is used to control the Rustfmt [configuration settings][cs]
+used at runtime.
+
+[cs]: https://rust-lang.github.io/rustfmt/
+
+This aspect is executed on any target which provides the `CrateInfo` provider. However
+users may tag a target with `norustfmt` to have it skipped. Additionally, generated
+source files are also ignored by this aspect.
+
+
+**ASPECT ATTRIBUTES**
+
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rustfmt_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
diff --git a/third_party/rules_rust/docs/index.md b/third_party/rules_rust/docs/index.md
new file mode 100644
index 0000000..022d88c
--- /dev/null
+++ b/third_party/rules_rust/docs/index.md
@@ -0,0 +1,85 @@
+# [Rules rust](https://github.com/bazelbuild/rules_rust)
+
+## Overview
+
+This repository provides rules for building [Rust][rust] projects with [Bazel][bazel].
+
+[bazel]: https://bazel.build/
+[rust]: http://www.rust-lang.org/
+
+<!-- TODO: Render generated docs on the github pages site again, https://bazelbuild.github.io/rules_rust/ -->
+
+<a name="setup"></a>
+
+## Setup
+
+To use the Rust rules, add the following to your `WORKSPACE` file to add the external repositories for the Rust toolchain:
+
+```python
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "rules_rust",
+    sha256 = "531bdd470728b61ce41cf7604dc4f9a115983e455d46ac1d0c1632f613ab9fc3",
+    strip_prefix = "rules_rust-d8238877c0e552639d3e057aadd6bfcf37592408",
+    urls = [
+        # `main` branch as of 2021-08-23
+        "https://github.com/bazelbuild/rules_rust/archive/d8238877c0e552639d3e057aadd6bfcf37592408.tar.gz",
+    ],
+)
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains()
+```
+
+The rules are under active development, as such the lastest commit on the
+`main` branch should be used. `main` is only tested against `4.0.0` as the
+minimum supported version of Bazel. Though previous versions may still be
+functional in certain environments.
+
+## Rules
+
+- [defs](defs.md): standard rust rules for building and testing libraries and binaries.
+- [rust_doc](rust_doc.md): rules for generating and testing rust documentation.
+- [rust_clippy](rust_clippy.md): rules for running [clippy](https://github.com/rust-lang/rust-clippy#readme).
+- [rust_fmt](rust_fmt.md): rules for running [rustfmt](https://github.com/rust-lang/rustfmt#readme).
+- [rust_proto](rust_proto.md): rules for generating [protobuf](https://developers.google.com/protocol-buffers).
+  and [gRPC](https://grpc.io) stubs.
+- [rust_bindgen](rust_bindgen.md): rules for generating C++ bindings.
+- [rust_wasm_bindgen](rust_wasm_bindgen.md): rules for generating [WebAssembly](https://www.rust-lang.org/what/wasm) bindings.
+- [cargo](cargo.md): Rules dedicated to Cargo compatibility. ie: [`build.rs` scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html).
+
+You can also browse the [full API in one page](flatten.md).
+
+### Experimental rules
+
+- [crate_universe](crate_universe.md): A repository rule for fetching dependencies from a crate registry.
+- [rust_analyzer](rust_analyzer.md): rules for generating `rust-project.json` files for [rust-analyzer](https://rust-analyzer.github.io/)
+
+## Specifying Rust version
+
+To build with a particular version of the Rust compiler, pass that version to [`rust_repositories`](flatten.md#rust_repositories):
+
+```python
+rust_repositories(version = "1.53.0", edition="2018")
+```
+
+As well as an exact version, `version` can be set to `"nightly"` or `"beta"`. If set to these values, `iso_date` must also be set:
+
+```python
+rust_repositories(version = "nightly", iso_date = "2021-06-16", edition="2018")
+```
+
+Similarly, `rustfmt_version` may also be configured:
+
+```python
+rust_repositories(rustfmt_version = "1.53.0")
+```
+
+## External Dependencies
+
+Currently, the most common approach to managing external dependencies is using
+[cargo-raze](https://github.com/google/cargo-raze) to generate `BUILD` files for Cargo crates.
diff --git a/third_party/rules_rust/docs/main.css b/third_party/rules_rust/docs/main.css
new file mode 100755
index 0000000..f506e12
--- /dev/null
+++ b/third_party/rules_rust/docs/main.css
@@ -0,0 +1,3 @@
+body{background-color:#fafafa}pre,code{font-family:'Liberation Mono', Consolas, Monaco, 'Andale Mono', monospace}pre{background-color:#eee;padding:20px;overflow-x:auto;word-wrap:normal}pre code{overflow-wrap:normal;white-space:pre}code{display:inline-block;font-size:90%;white-space:pre-wrap}.mdl-layout__drawer{background-color:#fff}.mdl-layout__drawer .mdl-layout-title{border-bottom:1px solid #e0e0e0;padding-left:24px}.drawer-nav ul{list-style:none;padding-left:0}.drawer-nav ul li{display:block;padding:0}.drawer-nav ul li ul li a{padding-left:44px;font-weight:400}.drawer-nav ul li a{display:block;flex-shrink:0;padding:15px 0 15px 22px;margin:0;font-weight:600;color:#757575;line-height:1em;text-decoration:none;cursor:pointer}.drawer-nav ul li a:active,.drawer-nav ul li a:hover{background-color:#f0f0f0}.drawer-nav ul li.active a{color:#4caf50;font-weight:500}h1.page-title{font-size:34px;font-weight:400;line-height:40px;margin-bottom:30px;color:#4caf50}p.lead{font-size:20px;line-height:32px}table{border-collapse:collapse;border-spacing:0;background-color:#fff;table-layout:auto}table thead th{background-color:#fafafa;border:1px solid #eee;color:#757575;padding:12px 12px 12px 24px;vertical-align:top}table tbody td{border:1px solid #eee;padding:12px 12px 12px 24px;vertical-align:top}table.params-table{width:100%}table.params-table col.col-param{width:25%}table.params-table col.col-description{width:75%}table.overview-table{width:100%}table.overview-table col.col-name{width:25%}table.overview-table col.col-description{width:75%}table.overview-table td p{margin:0}hr{margin-top:80px;margin-bottom:80px}nav.toc{border-left:5px solid #4caf50;padding-left:20px;margin-bottom:48px}nav.toc h1,nav.toc h2{font-size:15px;line-height:16px;padding-bottom:12px;margin-bottom:0;font-weight:400;color:#757575}nav.toc ul{list-style:none;margin-top:0;padding-left:0}nav.toc ul li{font-size:20px;line-height:40px}nav.toc ul li a{color:#4caf50}.page-content{margin-left:auto;margin-right:auto;padding-top:60px;padding-bottom:60px;width:760px}.page-content a{text-decoration:none}.page-content h1{font-size:34px;font-weight:400;line-height:40px;margin-bottom:30px;color:#4caf50}.page-content h2{font-size:24px;font-weight:400;line-height:32px;margin-bottom:30px;color:#4caf50}.page-content h3{font-size:20px;font-weight:400;line-height:32px;margin-bottom:30px;color:#4caf50}@media (max-width: 768px){.page-content{width:360px}}@media (min-width: 768px){.page-content{width:760px}}@media (min-width: 1476px){.page-content{width:1160px}}.mdl-mini-footer{padding-left:40px}
+
+/*# sourceMappingURL=main.css.map */
\ No newline at end of file
diff --git a/third_party/rules_rust/docs/page.bzl b/third_party/rules_rust/docs/page.bzl
new file mode 100644
index 0000000..b20db65
--- /dev/null
+++ b/third_party/rules_rust/docs/page.bzl
@@ -0,0 +1,59 @@
+"""A helper module for generating documentation for rules_rust"""
+
+def page(name, symbols, header_template = None):
+    """Define a collection of attributes used to generate a page of documentation
+
+    Note, all templates are Velocity files: https://velocity.apache.org/engine/devel/user-guide.html
+
+    Args:
+        name (str): The name of the page
+        symbols (list): A list of symbol names
+        header_template (Label, optional): The label of a `header_template` stardoc attribute
+
+    Returns:
+        tuple: The name of the page with the page content
+    """
+    return (name, struct(
+        name = name,
+        header_template = header_template,
+        symbols = symbols,
+    ))
+
+# buildifier: disable=unnamed-macro
+def gen_header(page):
+    """Generate a header with a table of contents
+
+    Args:
+        page (struct): A `page` struct
+    """
+    name = "%s_gen_header_vm" % page.name
+    outs = ["%s_gen_header.vm" % page.name]
+
+    # Set the top level header
+    page_names = [w.capitalize() for w in page.name.split("_")]
+    cmd = [
+        "echo '<!-- Generated with Stardoc: http://skydoc.bazel.build -->'",
+        "echo '# {}'".format(" ".join(page_names)),
+        "echo ''",
+    ]
+
+    # Add table of contents
+    cmd.extend(["echo '* [{rule}](#{rule})'".format(rule = s) for s in page.symbols])
+
+    # Render an optional header
+    if page.header_template:
+        cmd.extend([
+            "echo ''",
+            "cat $(execpath {})".format(page.header_template),
+        ])
+        srcs = [page.header_template]
+    else:
+        srcs = []
+
+    native.genrule(
+        name = name,
+        outs = outs,
+        cmd = "{\n" + "\n".join(cmd) + "\n} > $@",
+        srcs = srcs,
+        output_to_bindir = True,
+    )
diff --git a/third_party/rules_rust/docs/providers.md b/third_party/rules_rust/docs/providers.md
new file mode 100644
index 0000000..0a78246
--- /dev/null
+++ b/third_party/rules_rust/docs/providers.md
@@ -0,0 +1,91 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Providers
+
+* [CrateInfo](#CrateInfo)
+* [DepInfo](#DepInfo)
+* [StdLibInfo](#StdLibInfo)
+
+<a id="#CrateInfo"></a>
+
+## CrateInfo
+
+<pre>
+CrateInfo(<a href="#CrateInfo-aliases">aliases</a>, <a href="#CrateInfo-compile_data">compile_data</a>, <a href="#CrateInfo-deps">deps</a>, <a href="#CrateInfo-edition">edition</a>, <a href="#CrateInfo-is_test">is_test</a>, <a href="#CrateInfo-name">name</a>, <a href="#CrateInfo-output">output</a>, <a href="#CrateInfo-owner">owner</a>, <a href="#CrateInfo-proc_macro_deps">proc_macro_deps</a>, <a href="#CrateInfo-root">root</a>,
+          <a href="#CrateInfo-rustc_env">rustc_env</a>, <a href="#CrateInfo-srcs">srcs</a>, <a href="#CrateInfo-type">type</a>, <a href="#CrateInfo-wrapped_crate_type">wrapped_crate_type</a>)
+</pre>
+
+A provider containing general Crate information.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="CrateInfo-aliases"></a>aliases |  Dict[Label, String]: Renamed and aliased crates    |
+| <a id="CrateInfo-compile_data"></a>compile_data |  depset[File]: Compile data required by this crate.    |
+| <a id="CrateInfo-deps"></a>deps |  depset[DepVariantInfo]: This crate's (rust or cc) dependencies' providers.    |
+| <a id="CrateInfo-edition"></a>edition |  str: The edition of this crate.    |
+| <a id="CrateInfo-is_test"></a>is_test |  bool: If the crate is being compiled in a test context    |
+| <a id="CrateInfo-name"></a>name |  str: The name of this crate.    |
+| <a id="CrateInfo-output"></a>output |  File: The output File that will be produced, depends on crate type.    |
+| <a id="CrateInfo-owner"></a>owner |  Label: The label of the target that produced this CrateInfo    |
+| <a id="CrateInfo-proc_macro_deps"></a>proc_macro_deps |  depset[DepVariantInfo]: This crate's rust proc_macro dependencies' providers.    |
+| <a id="CrateInfo-root"></a>root |  File: The source File entrypoint to this crate, eg. lib.rs    |
+| <a id="CrateInfo-rustc_env"></a>rustc_env |  Dict[String, String]: Additional <code>"key": "value"</code> environment variables to set for rustc.    |
+| <a id="CrateInfo-srcs"></a>srcs |  depset[File]: All source Files that are part of the crate.    |
+| <a id="CrateInfo-type"></a>type |  str: The type of this crate (see [rustc --crate-type](https://doc.rust-lang.org/rustc/command-line-arguments.html#--crate-type-a-list-of-types-of-crates-for-the-compiler-to-emit)).    |
+| <a id="CrateInfo-wrapped_crate_type"></a>wrapped_crate_type |  str, optional: The original crate type for targets generated using a previously defined crate (typically tests using the <code>rust_test::crate</code> attribute)    |
+
+
+<a id="#DepInfo"></a>
+
+## DepInfo
+
+<pre>
+DepInfo(<a href="#DepInfo-dep_env">dep_env</a>, <a href="#DepInfo-direct_crates">direct_crates</a>, <a href="#DepInfo-link_search_path_files">link_search_path_files</a>, <a href="#DepInfo-transitive_build_infos">transitive_build_infos</a>,
+        <a href="#DepInfo-transitive_crate_outputs">transitive_crate_outputs</a>, <a href="#DepInfo-transitive_crates">transitive_crates</a>, <a href="#DepInfo-transitive_noncrates">transitive_noncrates</a>)
+</pre>
+
+A provider containing information about a Crate's dependencies.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="DepInfo-dep_env"></a>dep_env |  File: File with environment variables direct dependencies build scripts rely upon.    |
+| <a id="DepInfo-direct_crates"></a>direct_crates |  depset[AliasableDepInfo]    |
+| <a id="DepInfo-link_search_path_files"></a>link_search_path_files |  depset[File]: All transitive files containing search paths to pass to the linker    |
+| <a id="DepInfo-transitive_build_infos"></a>transitive_build_infos |  depset[BuildInfo]    |
+| <a id="DepInfo-transitive_crate_outputs"></a>transitive_crate_outputs |  depset[File]: All transitive crate outputs.    |
+| <a id="DepInfo-transitive_crates"></a>transitive_crates |  depset[CrateInfo]    |
+| <a id="DepInfo-transitive_noncrates"></a>transitive_noncrates |  depset[LinkerInput]: All transitive dependencies that aren't crates.    |
+
+
+<a id="#StdLibInfo"></a>
+
+## StdLibInfo
+
+<pre>
+StdLibInfo(<a href="#StdLibInfo-alloc_files">alloc_files</a>, <a href="#StdLibInfo-between_alloc_and_core_files">between_alloc_and_core_files</a>, <a href="#StdLibInfo-between_core_and_std_files">between_core_and_std_files</a>, <a href="#StdLibInfo-core_files">core_files</a>,
+           <a href="#StdLibInfo-dot_a_files">dot_a_files</a>, <a href="#StdLibInfo-self_contained_files">self_contained_files</a>, <a href="#StdLibInfo-srcs">srcs</a>, <a href="#StdLibInfo-std_files">std_files</a>, <a href="#StdLibInfo-std_rlibs">std_rlibs</a>)
+</pre>
+
+A collection of files either found within the `rust-stdlib` artifact or generated based on existing files.
+
+**FIELDS**
+
+
+| Name  | Description |
+| :------------- | :------------- |
+| <a id="StdLibInfo-alloc_files"></a>alloc_files |  List[File]: <code>.a</code> files related to the <code>alloc</code> module.    |
+| <a id="StdLibInfo-between_alloc_and_core_files"></a>between_alloc_and_core_files |  List[File]: <code>.a</code> files related to the <code>compiler_builtins</code> module.    |
+| <a id="StdLibInfo-between_core_and_std_files"></a>between_core_and_std_files |  List[File]: <code>.a</code> files related to all modules except <code>adler</code>, <code>alloc</code>, <code>compiler_builtins</code>, <code>core</code>, and <code>std</code>.    |
+| <a id="StdLibInfo-core_files"></a>core_files |  List[File]: <code>.a</code> files related to the <code>core</code> and <code>adler</code> modules    |
+| <a id="StdLibInfo-dot_a_files"></a>dot_a_files |  Depset[File]: Generated <code>.a</code> files    |
+| <a id="StdLibInfo-self_contained_files"></a>self_contained_files |  List[File]: All <code>.o</code> files from the <code>self-contained</code> directory.    |
+| <a id="StdLibInfo-srcs"></a>srcs |  List[Target]: All targets from the original <code>srcs</code> attribute.    |
+| <a id="StdLibInfo-std_files"></a>std_files |  Depset[File]: <code>.a</code> files associated with the <code>std</code> module.    |
+| <a id="StdLibInfo-std_rlibs"></a>std_rlibs |  List[File]: All <code>.rlib</code> files    |
+
+
diff --git a/third_party/rules_rust/docs/rust_analyzer.md b/third_party/rules_rust/docs/rust_analyzer.md
new file mode 100644
index 0000000..5a3c884
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_analyzer.md
@@ -0,0 +1,121 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Analyzer
+
+* [rust_analyzer](#rust_analyzer)
+* [rust_analyzer_aspect](#rust_analyzer_aspect)
+
+
+## Overview
+
+For [non-Cargo projects](https://rust-analyzer.github.io/manual.html#non-cargo-based-projects),
+[rust-analyzer](https://rust-analyzer.github.io/) depends on a `rust-project.json` file at the
+root of the project that describes its structure. The `rust_analyzer` rule facilitates generating
+such a file.
+
+### Setup
+
+First, add the following to the `WORKSPACE` file:
+
+```python
+load("@rules_rust//tools/rust_analyzer:deps.bzl", "rust_analyzer_deps")
+
+rust_analyzer_deps()
+```
+
+Next, add the following lines to the `.bazelrc` file of your workspace:
+```
+build --repo_env=RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS=true
+```
+
+This will ensure rust source code is available to `rust-analyzer`. Users
+can also set `include_rustc_srcs = True` on any `rust_repository` or
+`rust_repositories` calls in the workspace but the environment variable
+has higher priority and can override the attribute.
+
+Finally, run `bazel run @rules_rust//tools/rust_analyzer:gen_rust_project`
+whenever dependencies change to regenerate the `rust-project.json` file. It
+should be added to `.gitignore` because it is effectively a build artifact.
+Once the `rust-project.json` has been generated in the project root,
+rust-analyzer can pick it up upon restart.
+
+#### VSCode
+
+To set this up using [VSCode](https://code.visualstudio.com/), users should first install the
+[rust_analyzer plugin](https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer).
+With that in place, the following task can be added to the `.vscode/tasks.json` file of the workspace
+to ensure a `rust-project.json` file is created and up to date when the editor is opened.
+
+```json
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Generate rust-project.json",
+            "command": "bazel",
+            "args": ["run", "@rules_rust//tools/rust_analyzer:gen_rust_project"],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "group": "build",
+            "problemMatcher": [],
+            "presentation": {
+                "reveal": "never",
+                "panel": "dedicated",
+            },
+            "runOptions": {
+                "runOn": "folderOpen"
+            }
+        },
+    ]
+}
+```
+
+
+<a id="#rust_analyzer"></a>
+
+## rust_analyzer
+
+<pre>
+rust_analyzer(<a href="#rust_analyzer-name">name</a>, <a href="#rust_analyzer-targets">targets</a>)
+</pre>
+
+Deprecated: gen_rust_project can now create a rust-project.json without a rust_analyzer rule.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_analyzer-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_analyzer-targets"></a>targets |  List of all targets to be included in the index   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_analyzer_aspect"></a>
+
+## rust_analyzer_aspect
+
+<pre>
+rust_analyzer_aspect(<a href="#rust_analyzer_aspect-name">name</a>)
+</pre>
+
+Annotates rust rules with RustAnalyzerInfo later used to build a rust-project.json
+
+**ASPECT ATTRIBUTES**
+
+
+| Name | Type |
+| :------------- | :------------- |
+| deps| String |
+| proc_macro_deps| String |
+| crate| String |
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_analyzer_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
diff --git a/third_party/rules_rust/docs/rust_analyzer.vm b/third_party/rules_rust/docs/rust_analyzer.vm
new file mode 100644
index 0000000..e366960
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_analyzer.vm
@@ -0,0 +1,66 @@
+#[[
+## Overview
+
+For [non-Cargo projects](https://rust-analyzer.github.io/manual.html#non-cargo-based-projects),
+[rust-analyzer](https://rust-analyzer.github.io/) depends on a `rust-project.json` file at the
+root of the project that describes its structure. The `rust_analyzer` rule facilitates generating
+such a file.
+
+### Setup
+
+First, add the following to the `WORKSPACE` file:
+
+```python
+load("@rules_rust//tools/rust_analyzer:deps.bzl", "rust_analyzer_deps")
+
+rust_analyzer_deps()
+```
+
+Next, add the following lines to the `.bazelrc` file of your workspace:
+```
+build --repo_env=RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS=true
+```
+
+This will ensure rust source code is available to `rust-analyzer`. Users
+can also set `include_rustc_srcs = True` on any `rust_repository` or
+`rust_repositories` calls in the workspace but the environment variable
+has higher priority and can override the attribute.
+
+Finally, run `bazel run @rules_rust//tools/rust_analyzer:gen_rust_project`
+whenever dependencies change to regenerate the `rust-project.json` file. It
+should be added to `.gitignore` because it is effectively a build artifact.
+Once the `rust-project.json` has been generated in the project root,
+rust-analyzer can pick it up upon restart.
+
+#### VSCode
+
+To set this up using [VSCode](https://code.visualstudio.com/), users should first install the
+[rust_analyzer plugin](https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer).
+With that in place, the following task can be added to the `.vscode/tasks.json` file of the workspace
+to ensure a `rust-project.json` file is created and up to date when the editor is opened.
+
+```json
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Generate rust-project.json",
+            "command": "bazel",
+            "args": ["run", "@rules_rust//tools/rust_analyzer:gen_rust_project"],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "group": "build",
+            "problemMatcher": [],
+            "presentation": {
+                "reveal": "never",
+                "panel": "dedicated",
+            },
+            "runOptions": {
+                "runOn": "folderOpen"
+            }
+        },
+    ]
+}
+```
+]]#
diff --git a/third_party/rules_rust/docs/rust_bindgen.md b/third_party/rules_rust/docs/rust_bindgen.md
new file mode 100644
index 0000000..6127ede
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_bindgen.md
@@ -0,0 +1,93 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Bindgen
+
+* [rust_bindgen_library](#rust_bindgen_library)
+* [rust_bindgen_repositories](#rust_bindgen_repositories)
+* [rust_bindgen_toolchain](#rust_bindgen_toolchain)
+* [rust_bindgen](#rust_bindgen)
+
+<a id="#rust_bindgen"></a>
+
+## rust_bindgen
+
+<pre>
+rust_bindgen(<a href="#rust_bindgen-name">name</a>, <a href="#rust_bindgen-bindgen_flags">bindgen_flags</a>, <a href="#rust_bindgen-cc_lib">cc_lib</a>, <a href="#rust_bindgen-clang_flags">clang_flags</a>, <a href="#rust_bindgen-header">header</a>, <a href="#rust_bindgen-rustfmt">rustfmt</a>)
+</pre>
+
+Generates a rust source file from a cc_library and a header.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_bindgen-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_bindgen-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.   | List of strings | optional | [] |
+| <a id="rust_bindgen-cc_lib"></a>cc_lib |  The cc_library that contains the .h file. This is used to find the transitive includes.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen-clang_flags"></a>clang_flags |  Flags to pass directly to the clang executable.   | List of strings | optional | [] |
+| <a id="rust_bindgen-header"></a>header |  The .h file to generate bindings for.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen-rustfmt"></a>rustfmt |  Enable or disable running rustfmt on the generated file.   | Boolean | optional | True |
+
+
+<a id="#rust_bindgen_toolchain"></a>
+
+## rust_bindgen_toolchain
+
+<pre>
+rust_bindgen_toolchain(<a href="#rust_bindgen_toolchain-name">name</a>, <a href="#rust_bindgen_toolchain-bindgen">bindgen</a>, <a href="#rust_bindgen_toolchain-clang">clang</a>, <a href="#rust_bindgen_toolchain-libclang">libclang</a>, <a href="#rust_bindgen_toolchain-libstdcxx">libstdcxx</a>, <a href="#rust_bindgen_toolchain-rustfmt">rustfmt</a>)
+</pre>
+
+The tools required for the `rust_bindgen` rule.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_bindgen_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_bindgen_toolchain-bindgen"></a>bindgen |  The label of a <code>bindgen</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-clang"></a>clang |  The label of a <code>clang</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-libclang"></a>libclang |  A cc_library that provides bindgen's runtime dependency on libclang.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-libstdcxx"></a>libstdcxx |  A cc_library that satisfies libclang's libstdc++ dependency. This is used to make the execution of clang hermetic. If None, system libraries will be used instead.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_bindgen_toolchain-rustfmt"></a>rustfmt |  The label of a <code>rustfmt</code> executable. If this is not provided, falls back to the rust_toolchain rustfmt.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+
+
+<a id="#rust_bindgen_library"></a>
+
+## rust_bindgen_library
+
+<pre>
+rust_bindgen_library(<a href="#rust_bindgen_library-name">name</a>, <a href="#rust_bindgen_library-header">header</a>, <a href="#rust_bindgen_library-cc_lib">cc_lib</a>, <a href="#rust_bindgen_library-bindgen_flags">bindgen_flags</a>, <a href="#rust_bindgen_library-clang_flags">clang_flags</a>, <a href="#rust_bindgen_library-rustfmt">rustfmt</a>, <a href="#rust_bindgen_library-kwargs">kwargs</a>)
+</pre>
+
+Generates a rust source file for `header`, and builds a rust_library.
+
+Arguments are the same as `rust_bindgen`, and `kwargs` are passed directly to rust_library.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_bindgen_library-name"></a>name |  A unique name for this target.   |  none |
+| <a id="rust_bindgen_library-header"></a>header |  The label of the .h file to generate bindings for.   |  none |
+| <a id="rust_bindgen_library-cc_lib"></a>cc_lib |  The label of the cc_library that contains the .h file. This is used to find the transitive includes.   |  none |
+| <a id="rust_bindgen_library-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://rust-lang.github.io/rust-bindgen/ for details.   |  <code>None</code> |
+| <a id="rust_bindgen_library-clang_flags"></a>clang_flags |  Flags to pass directly to the clang executable.   |  <code>None</code> |
+| <a id="rust_bindgen_library-rustfmt"></a>rustfmt |  Enable or disable running rustfmt on the generated file.   |  <code>True</code> |
+| <a id="rust_bindgen_library-kwargs"></a>kwargs |  Arguments to forward to the underlying <code>rust_library</code> rule.   |  none |
+
+
+<a id="#rust_bindgen_repositories"></a>
+
+## rust_bindgen_repositories
+
+<pre>
+rust_bindgen_repositories()
+</pre>
+
+Declare dependencies needed for bindgen.
+
+
+
diff --git a/third_party/rules_rust/docs/rust_clippy.md b/third_party/rules_rust/docs/rust_clippy.md
new file mode 100644
index 0000000..834b23b
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_clippy.md
@@ -0,0 +1,141 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Clippy
+
+* [rust_clippy](#rust_clippy)
+* [rust_clippy_aspect](#rust_clippy_aspect)
+
+
+## Overview
+
+
+[Clippy][clippy] is a tool for catching common mistakes in Rust code and improving it. An
+expansive list of lints and the justification can be found in their [documentation][docs].
+
+[clippy]: https://github.com/rust-lang/rust-clippy#readme
+[docs]: https://rust-lang.github.io/rust-clippy/
+
+
+### Setup
+
+
+Simply add the following to the `.bazelrc` file in the root of your workspace:
+
+```text
+build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build --output_groups=+clippy_checks
+```
+
+This will enable clippy on all [Rust targets](./defs.md).
+
+Note that targets tagged with `noclippy` will not perform clippy checks
+
+To use a local clippy.toml, add the following flag to your `.bazelrc`. Note that due to
+the upstream implementation of clippy, this file must be named either `.clippy.toml` or
+`clippy.toml`. Using a custom config file requires Rust 1.34.0 or newer.
+
+```text
+build --@rules_rust//:clippy.toml=//:clippy.toml
+```
+
+<a id="#rust_clippy"></a>
+
+## rust_clippy
+
+<pre>
+rust_clippy(<a href="#rust_clippy-name">name</a>, <a href="#rust_clippy-deps">deps</a>)
+</pre>
+
+Executes the clippy checker on a specific target.
+
+Similar to `rust_clippy_aspect`, but allows specifying a list of dependencies within the build system.
+
+For example, given the following example targets:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Rust clippy can be set as a build target with the following:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_clippy")
+
+rust_clippy(
+    name = "hello_library_clippy",
+    testonly = True,
+    deps = [
+        ":hello_lib",
+        ":greeting_test",
+    ],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_clippy-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_clippy-deps"></a>deps |  Rust targets to run clippy on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_clippy_aspect"></a>
+
+## rust_clippy_aspect
+
+<pre>
+rust_clippy_aspect(<a href="#rust_clippy_aspect-name">name</a>)
+</pre>
+
+Executes the clippy checker on specified targets.
+
+This aspect applies to existing rust_library, rust_test, and rust_binary rules.
+
+As an example, if the following is defined in `examples/hello_lib/BUILD.bazel`:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Then the targets can be analyzed with clippy using the following command:
+
+```output
+$ bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect               --output_groups=clippy_checks //hello_lib:all
+```
+
+
+**ASPECT ATTRIBUTES**
+
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_clippy_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
diff --git a/third_party/rules_rust/docs/rust_clippy.vm b/third_party/rules_rust/docs/rust_clippy.vm
new file mode 100644
index 0000000..abfc478
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_clippy.vm
@@ -0,0 +1,32 @@
+#[[
+## Overview
+]]#
+
+[Clippy][clippy] is a tool for catching common mistakes in Rust code and improving it. An
+expansive list of lints and the justification can be found in their [documentation][docs].
+
+[clippy]: https://github.com/rust-lang/rust-clippy#readme
+[docs]: https://rust-lang.github.io/rust-clippy/
+
+#[[
+### Setup
+]]#
+
+Simply add the following to the `.bazelrc` file in the root of your workspace:
+
+```text
+build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build --output_groups=+clippy_checks
+```
+
+This will enable clippy on all [Rust targets](./defs.md).
+
+Note that targets tagged with `noclippy` will not perform clippy checks
+
+To use a local clippy.toml, add the following flag to your `.bazelrc`. Note that due to
+the upstream implementation of clippy, this file must be named either `.clippy.toml` or
+`clippy.toml`. Using a custom config file requires Rust 1.34.0 or newer.
+
+```text
+build --@rules_rust//:clippy.toml=//:clippy.toml
+```
diff --git a/third_party/rules_rust/docs/rust_doc.md b/third_party/rules_rust/docs/rust_doc.md
new file mode 100644
index 0000000..cf5bf01
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_doc.md
@@ -0,0 +1,119 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Doc
+
+* [rust_doc](#rust_doc)
+* [rust_doc_test](#rust_doc_test)
+
+<a id="#rust_doc"></a>
+
+## rust_doc
+
+<pre>
+rust_doc(<a href="#rust_doc-name">name</a>, <a href="#rust_doc-crate">crate</a>, <a href="#rust_doc-html_after_content">html_after_content</a>, <a href="#rust_doc-html_before_content">html_before_content</a>, <a href="#rust_doc-html_in_header">html_in_header</a>, <a href="#rust_doc-markdown_css">markdown_css</a>)
+</pre>
+
+Generates code documentation.
+
+Example:
+Suppose you have the following directory structure for a Rust library crate:
+
+```
+[workspace]/
+    WORKSPACE
+    hello_lib/
+        BUILD
+        src/
+            lib.rs
+```
+
+To build [`rustdoc`][rustdoc] documentation for the `hello_lib` crate, define     a `rust_doc` rule that depends on the the `hello_lib` `rust_library` target:
+
+[rustdoc]: https://doc.rust-lang.org/book/documentation.html
+
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_doc(
+    name = "hello_lib_doc",
+    crate = ":hello_lib",
+)
+```
+
+Running `bazel build //hello_lib:hello_lib_doc` will build a zip file containing     the documentation for the `hello_lib` library crate generated by `rustdoc`.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_doc-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_doc-crate"></a>crate |  The label of the target to generate code documentation for.<br><br><code>rust_doc</code> can generate HTML code documentation for the source files of <code>rust_library</code> or <code>rust_binary</code> targets.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_doc-html_after_content"></a>html_after_content |  File to add in <code>&lt;body&gt;</code>, after content.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-html_before_content"></a>html_before_content |  File to add in <code>&lt;body&gt;</code>, before content.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-html_in_header"></a>html_in_header |  File to add to <code>&lt;head&gt;</code>.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_doc-markdown_css"></a>markdown_css |  CSS files to include via <code>&lt;link&gt;</code> in a rendered Markdown file.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_doc_test"></a>
+
+## rust_doc_test
+
+<pre>
+rust_doc_test(<a href="#rust_doc_test-name">name</a>, <a href="#rust_doc_test-crate">crate</a>)
+</pre>
+
+Runs Rust documentation tests.
+
+Example:
+
+Suppose you have the following directory structure for a Rust library crate:
+
+```output
+[workspace]/
+WORKSPACE
+hello_lib/
+    BUILD
+    src/
+        lib.rs
+```
+
+To run [documentation tests][doc-test] for the `hello_lib` crate, define a `rust_doc_test`         target that depends on the `hello_lib` `rust_library` target:
+
+[doc-test]: https://doc.rust-lang.org/book/documentation.html#documentation-as-tests
+
+```python
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_doc_test(
+    name = "hello_lib_doc_test",
+    crate = ":hello_lib",
+)
+```
+
+Running `bazel test //hello_lib:hello_lib_doc_test` will run all documentation tests for the `hello_lib` library crate.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_doc_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_doc_test-crate"></a>crate |  The label of the target to generate code documentation for. <code>rust_doc_test</code> can generate HTML code documentation for the source files of <code>rust_library</code> or <code>rust_binary</code> targets.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+
+
diff --git a/third_party/rules_rust/docs/rust_fmt.md b/third_party/rules_rust/docs/rust_fmt.md
new file mode 100644
index 0000000..e97c821
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_fmt.md
@@ -0,0 +1,104 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Fmt
+
+* [rustfmt_aspect](#rustfmt_aspect)
+* [rustfmt_test](#rustfmt_test)
+
+
+## Overview
+
+
+[Rustfmt][rustfmt] is a tool for formatting Rust code according to style guidelines. 
+By default, Rustfmt uses a style which conforms to the [Rust style guide][rsg] that
+has been formalized through the [style RFC process][rfcp]. A complete list of all
+configuration options can be found in the [Rustfmt GitHub Pages][rgp].
+
+
+
+### Setup
+
+
+Formatting your Rust targets' source code requires no setup outside of loading `rules_rust`
+in your workspace. Simply run `bazel run @rules_rust//:rustfmt` to format source code.
+
+In addition to this formatter, a check can be added to your build phase using the [rustfmt_aspect](#rustfmt-aspect)
+aspect. Simply add the following to a `.bazelrc` file to enable this check.
+
+```text
+build --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build --output_groups=+rustfmt_checks
+```
+
+It's recommended to only enable this aspect in your CI environment so formatting issues do not
+impact user's ability to rapidly iterate on changes.
+
+The `rustfmt_aspect` also uses a `--@rules_rust//:rustfmt.toml` setting which determines the
+[configuration file][rgp] used by the formatter (`@rules_rust//tools/rustfmt`) and the aspect
+(`rustfmt_aspect`). This flag can be added to your `.bazelrc` file to ensure a consistent config
+file is used whenever `rustfmt` is run:
+
+```text
+build --@rules_rust//:rustfmt.toml=//:rustfmt.toml
+```
+
+[rustfmt]: https://github.com/rust-lang/rustfmt#readme
+[rsg]: https://github.com/rust-lang-nursery/fmt-rfcs/blob/master/guide/guide.md
+[rfcp]: https://github.com/rust-lang-nursery/fmt-rfcs
+[rgp]: https://rust-lang.github.io/rustfmt/
+
+<a id="#rustfmt_test"></a>
+
+## rustfmt_test
+
+<pre>
+rustfmt_test(<a href="#rustfmt_test-name">name</a>, <a href="#rustfmt_test-targets">targets</a>)
+</pre>
+
+A test rule for performing `rustfmt --check` on a set of targets
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rustfmt_test-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rustfmt_test-targets"></a>targets |  Rust targets to run <code>rustfmt --check</code> on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rustfmt_aspect"></a>
+
+## rustfmt_aspect
+
+<pre>
+rustfmt_aspect(<a href="#rustfmt_aspect-name">name</a>)
+</pre>
+
+This aspect is used to gather information about a crate for use in rustfmt and perform rustfmt checks
+
+Output Groups:
+
+- `rustfmt_manifest`: A manifest used by rustfmt binaries to provide crate specific settings.
+- `rustfmt_checks`: Executes `rustfmt --check` on the specified target.
+
+The build setting `@rules_rust//:rustfmt.toml` is used to control the Rustfmt [configuration settings][cs]
+used at runtime.
+
+[cs]: https://rust-lang.github.io/rustfmt/
+
+This aspect is executed on any target which provides the `CrateInfo` provider. However
+users may tag a target with `norustfmt` to have it skipped. Additionally, generated
+source files are also ignored by this aspect.
+
+
+**ASPECT ATTRIBUTES**
+
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rustfmt_aspect-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |   |
+
+
diff --git a/third_party/rules_rust/docs/rust_fmt.vm b/third_party/rules_rust/docs/rust_fmt.vm
new file mode 100644
index 0000000..47d5af0
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_fmt.vm
@@ -0,0 +1,41 @@
+#[[
+## Overview
+]]#
+
+[Rustfmt][rustfmt] is a tool for formatting Rust code according to style guidelines. 
+By default, Rustfmt uses a style which conforms to the [Rust style guide][rsg] that
+has been formalized through the [style RFC process][rfcp]. A complete list of all
+configuration options can be found in the [Rustfmt GitHub Pages][rgp].
+
+
+#[[
+### Setup
+]]#
+
+Formatting your Rust targets' source code requires no setup outside of loading `rules_rust`
+in your workspace. Simply run `bazel run @rules_rust//:rustfmt` to format source code.
+
+In addition to this formatter, a check can be added to your build phase using the [rustfmt_aspect](#rustfmt-aspect)
+aspect. Simply add the following to a `.bazelrc` file to enable this check.
+
+```text
+build --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build --output_groups=+rustfmt_checks
+```
+
+It's recommended to only enable this aspect in your CI environment so formatting issues do not
+impact user's ability to rapidly iterate on changes.
+
+The `rustfmt_aspect` also uses a `--@rules_rust//:rustfmt.toml` setting which determines the
+[configuration file][rgp] used by the formatter (`@rules_rust//tools/rustfmt`) and the aspect
+(`rustfmt_aspect`). This flag can be added to your `.bazelrc` file to ensure a consistent config
+file is used whenever `rustfmt` is run:
+
+```text
+build --@rules_rust//:rustfmt.toml=//:rustfmt.toml
+```
+
+[rustfmt]: https://github.com/rust-lang/rustfmt#readme
+[rsg]: https://github.com/rust-lang-nursery/fmt-rfcs/blob/master/guide/guide.md
+[rfcp]: https://github.com/rust-lang-nursery/fmt-rfcs
+[rgp]: https://rust-lang.github.io/rustfmt/
diff --git a/third_party/rules_rust/docs/rust_proto.md b/third_party/rules_rust/docs/rust_proto.md
new file mode 100644
index 0000000..dfba0b2
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_proto.md
@@ -0,0 +1,294 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Proto
+
+* [rust_grpc_library](#rust_grpc_library)
+* [rust_proto_library](#rust_proto_library)
+* [rust_proto_repositories](#rust_proto_repositories)
+* [rust_proto_transitive_repositories](#rust_proto_transitive_repositories)
+* [rust_proto_toolchain](#rust_proto_toolchain)
+
+
+## Overview
+
+These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel.
+
+[rust]: http://www.rust-lang.org/
+[protobuf]: https://developers.google.com/protocol-buffers/
+[grpc]: https://grpc.io
+
+See the [protobuf example](../examples/proto) for a more complete example of use.
+
+### Setup
+
+To use the Rust proto rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust proto toolchain (in addition to the [rust rules setup](..)):
+
+```python
+load("@rules_rust//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+
+load("@rules_rust//proto:transitive_repositories.bzl", "rust_proto_transitive_repositories")
+
+rust_proto_transitive_repositories()
+```
+
+[raze]: https://github.com/google/cargo-raze
+
+This will load crate dependencies of protobuf that are generated using
+[cargo raze][raze] inside the rules_rust
+repository. However, using those dependencies might conflict with other uses
+of [cargo raze][raze]. If you need to change
+those dependencies, please see the [dedicated section below](#custom-deps).
+
+For additional information about Bazel toolchains, see [here](https://docs.bazel.build/versions/master/toolchains.html).
+
+## <a name="custom-deps">Customizing dependencies
+
+These rules depends on the [`protobuf`](https://crates.io/crates/protobuf) and
+the [`grpc`](https://crates.io/crates/grpc) crates in addition to the [protobuf
+compiler](https://github.com/google/protobuf). To obtain these crates,
+`rust_proto_repositories` imports the given crates using BUILD files generated with
+[`cargo raze`][raze].
+
+If you want to either change the protobuf and gRPC rust compilers, or to
+simply use [`cargo raze`][raze] in a more
+complex scenario (with more dependencies), you must redefine those
+dependencies.
+
+To do this, once you've imported the needed dependencies (see our
+[Cargo.toml](raze/Cargo.toml) file to see the default dependencies), you
+need to create your own toolchain. To do so you can create a BUILD
+file with your toolchain definition, for example:
+
+```python
+load("@rules_rust//proto:toolchain.bzl", "rust_proto_toolchain")
+
+rust_proto_toolchain(
+    name = "proto-toolchain-impl",
+    # Path to the protobuf compiler.
+    protoc = "@com_google_protobuf//:protoc",
+    # Protobuf compiler plugin to generate rust gRPC stubs.
+    grpc_plugin = "//cargo_raze/remote:cargo_bin_protoc_gen_rust_grpc",
+    # Protobuf compiler plugin to generate rust protobuf stubs.
+    proto_plugin = "//cargo_raze/remote:cargo_bin_protoc_gen_rust",
+)
+
+toolchain(
+    name = "proto-toolchain",
+    toolchain = ":proto-toolchain-impl",
+    toolchain_type = "@rules_rust//proto:toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:proto-toolchain")
+```
+
+Finally, you might want to set the `rust_deps` attribute in
+`rust_proto_library` and `rust_grpc_library` to change the compile-time
+dependencies:
+
+```python
+rust_proto_library(
+    ...
+    rust_deps = ["//cargo_raze/remote:protobuf"],
+    ...
+)
+
+rust_grpc_library(
+    ...
+    rust_deps = [
+        "//cargo_raze/remote:protobuf",
+        "//cargo_raze/remote:grpc",
+        "//cargo_raze/remote:tls_api",
+        "//cargo_raze/remote:tls_api_stub",
+    ],
+    ...
+)
+```
+
+__Note__: Ideally, we would inject those dependencies from the toolchain,
+but due to [bazelbuild/bazel#6889](https://github.com/bazelbuild/bazel/issues/6889)
+all dependencies added via the toolchain ends-up being in the wrong
+configuration.
+
+
+<a id="#rust_grpc_library"></a>
+
+## rust_grpc_library
+
+<pre>
+rust_grpc_library(<a href="#rust_grpc_library-name">name</a>, <a href="#rust_grpc_library-deps">deps</a>, <a href="#rust_grpc_library-rust_deps">rust_deps</a>)
+</pre>
+
+Builds a Rust library crate from a set of `proto_library`s suitable for gRPC.
+
+Example:
+
+```python
+load("//proto:proto.bzl", "rust_grpc_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_grpc_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_service",
+    srcs = ["my_service.rs"],
+    deps = [":rust"],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_grpc_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_grpc_library-deps"></a>deps |  List of proto_library dependencies that will be built. One crate for each proto_library will be created with the corresponding gRPC stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+| <a id="rust_grpc_library-rust_deps"></a>rust_deps |  The crates the generated library depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_proto_library"></a>
+
+## rust_proto_library
+
+<pre>
+rust_proto_library(<a href="#rust_proto_library-name">name</a>, <a href="#rust_proto_library-deps">deps</a>, <a href="#rust_proto_library-rust_deps">rust_deps</a>)
+</pre>
+
+Builds a Rust library crate from a set of `proto_library`s.
+
+Example:
+
+```python
+load("@rules_rust//proto:proto.bzl", "rust_proto_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_proto_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_proto_binary",
+    srcs = ["my_proto_binary.rs"],
+    deps = [":rust"],
+)
+```
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proto_library-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proto_library-deps"></a>deps |  List of proto_library dependencies that will be built. One crate for each proto_library will be created with the corresponding stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+| <a id="rust_proto_library-rust_deps"></a>rust_deps |  The crates the generated library depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [] |
+
+
+<a id="#rust_proto_toolchain"></a>
+
+## rust_proto_toolchain
+
+<pre>
+rust_proto_toolchain(<a href="#rust_proto_toolchain-name">name</a>, <a href="#rust_proto_toolchain-edition">edition</a>, <a href="#rust_proto_toolchain-grpc_compile_deps">grpc_compile_deps</a>, <a href="#rust_proto_toolchain-grpc_plugin">grpc_plugin</a>, <a href="#rust_proto_toolchain-proto_compile_deps">proto_compile_deps</a>,
+                     <a href="#rust_proto_toolchain-proto_plugin">proto_plugin</a>, <a href="#rust_proto_toolchain-protoc">protoc</a>)
+</pre>
+
+Declares a Rust Proto toolchain for use.
+
+This is used to configure proto compilation and can be used to set different protobuf compiler plugin.
+
+Example:
+
+Suppose a new nicer gRPC plugin has came out. The new plugin can be used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//proto:toolchain.bzl', 'rust_proto_toolchain')
+
+rust_proto_toolchain(
+   name="rust_proto_impl",
+   grpc_plugin="@rust_grpc//:grpc_plugin",
+   grpc_compile_deps=["@rust_grpc//:grpc_deps"],
+)
+
+toolchain(
+    name="rust_proto",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_proto_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to register_toolchains in the WORKSPACE, or pass it to the `--extra_toolchains` flag for Bazel, and it will be used.
+
+See @rules_rust//proto:BUILD for examples of defining the toolchain.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_proto_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_proto_toolchain-edition"></a>edition |  The edition used by the generated rust source.   | String | optional | "2018" |
+| <a id="rust_proto_toolchain-grpc_compile_deps"></a>grpc_compile_deps |  The crates the generated grpc libraries depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [Label("//proto/raze:protobuf"), Label("//proto/raze:grpc"), Label("//proto/raze:tls_api"), Label("//proto/raze:tls_api_stub")] |
+| <a id="rust_proto_toolchain-grpc_plugin"></a>grpc_plugin |  The location of the Rust protobuf compiler plugin to generate rust gRPC stubs.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | //proto:protoc_gen_rust_grpc |
+| <a id="rust_proto_toolchain-proto_compile_deps"></a>proto_compile_deps |  The crates the generated protobuf libraries depends on.   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | optional | [Label("//proto/raze:protobuf")] |
+| <a id="rust_proto_toolchain-proto_plugin"></a>proto_plugin |  The location of the Rust protobuf compiler plugin used to generate rust sources.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | //proto:protoc_gen_rust |
+| <a id="rust_proto_toolchain-protoc"></a>protoc |  The location of the <code>protoc</code> binary. It should be an executable target.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | @com_google_protobuf//:protoc |
+
+
+<a id="#rust_proto_repositories"></a>
+
+## rust_proto_repositories
+
+<pre>
+rust_proto_repositories(<a href="#rust_proto_repositories-register_default_toolchain">register_default_toolchain</a>)
+</pre>
+
+Declare dependencies needed for proto compilation.
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_proto_repositories-register_default_toolchain"></a>register_default_toolchain |  If True, the default [rust_proto_toolchain](#rust_proto_toolchain) (<code>@rules_rust//proto:default-proto-toolchain</code>) is registered. This toolchain requires a set of dependencies that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.   |  <code>True</code> |
+
+
+<a id="#rust_proto_transitive_repositories"></a>
+
+## rust_proto_transitive_repositories
+
+<pre>
+rust_proto_transitive_repositories()
+</pre>
+
+Load transitive dependencies of the `@rules_rust//proto` rules.
+
+This macro should be called immediately after the `rust_proto_repositories` macro.
+
+
+
diff --git a/third_party/rules_rust/docs/rust_proto.vm b/third_party/rules_rust/docs/rust_proto.vm
new file mode 100644
index 0000000..9067510
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_proto.vm
@@ -0,0 +1,109 @@
+#[[
+## Overview
+
+These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel.
+
+[rust]: http://www.rust-lang.org/
+[protobuf]: https://developers.google.com/protocol-buffers/
+[grpc]: https://grpc.io
+
+See the [protobuf example](../examples/proto) for a more complete example of use.
+
+### Setup
+
+To use the Rust proto rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust proto toolchain (in addition to the [rust rules setup](..)):
+
+```python
+load("@rules_rust//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+
+load("@rules_rust//proto:transitive_repositories.bzl", "rust_proto_transitive_repositories")
+
+rust_proto_transitive_repositories()
+```
+
+[raze]: https://github.com/google/cargo-raze
+
+This will load crate dependencies of protobuf that are generated using
+[cargo raze][raze] inside the rules_rust
+repository. However, using those dependencies might conflict with other uses
+of [cargo raze][raze]. If you need to change
+those dependencies, please see the [dedicated section below](#custom-deps).
+
+For additional information about Bazel toolchains, see [here](https://docs.bazel.build/versions/master/toolchains.html).
+
+## <a name="custom-deps">Customizing dependencies
+
+These rules depends on the [`protobuf`](https://crates.io/crates/protobuf) and
+the [`grpc`](https://crates.io/crates/grpc) crates in addition to the [protobuf
+compiler](https://github.com/google/protobuf). To obtain these crates,
+`rust_proto_repositories` imports the given crates using BUILD files generated with
+[`cargo raze`][raze].
+
+If you want to either change the protobuf and gRPC rust compilers, or to
+simply use [`cargo raze`][raze] in a more
+complex scenario (with more dependencies), you must redefine those
+dependencies.
+
+To do this, once you've imported the needed dependencies (see our
+[Cargo.toml](raze/Cargo.toml) file to see the default dependencies), you
+need to create your own toolchain. To do so you can create a BUILD
+file with your toolchain definition, for example:
+
+```python
+load("@rules_rust//proto:toolchain.bzl", "rust_proto_toolchain")
+
+rust_proto_toolchain(
+    name = "proto-toolchain-impl",
+    # Path to the protobuf compiler.
+    protoc = "@com_google_protobuf//:protoc",
+    # Protobuf compiler plugin to generate rust gRPC stubs.
+    grpc_plugin = "//cargo_raze/remote:cargo_bin_protoc_gen_rust_grpc",
+    # Protobuf compiler plugin to generate rust protobuf stubs.
+    proto_plugin = "//cargo_raze/remote:cargo_bin_protoc_gen_rust",
+)
+
+toolchain(
+    name = "proto-toolchain",
+    toolchain = ":proto-toolchain-impl",
+    toolchain_type = "@rules_rust//proto:toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:proto-toolchain")
+```
+
+Finally, you might want to set the `rust_deps` attribute in
+`rust_proto_library` and `rust_grpc_library` to change the compile-time
+dependencies:
+
+```python
+rust_proto_library(
+    ...
+    rust_deps = ["//cargo_raze/remote:protobuf"],
+    ...
+)
+
+rust_grpc_library(
+    ...
+    rust_deps = [
+        "//cargo_raze/remote:protobuf",
+        "//cargo_raze/remote:grpc",
+        "//cargo_raze/remote:tls_api",
+        "//cargo_raze/remote:tls_api_stub",
+    ],
+    ...
+)
+```
+
+__Note__: Ideally, we would inject those dependencies from the toolchain,
+but due to [bazelbuild/bazel#6889](https://github.com/bazelbuild/bazel/issues/6889)
+all dependencies added via the toolchain ends-up being in the wrong
+configuration.
+]]#
diff --git a/third_party/rules_rust/docs/rust_repositories.md b/third_party/rules_rust/docs/rust_repositories.md
new file mode 100644
index 0000000..8f68ff7
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_repositories.md
@@ -0,0 +1,224 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Repositories
+
+* [rules_rust_dependencies](#rules_rust_dependencies)
+* [rust_register_toolchains](#rust_register_toolchains)
+* [rust_repositories](#rust_repositories)
+* [rust_repository_set](#rust_repository_set)
+* [rust_stdlib_filegroup](#rust_stdlib_filegroup)
+* [rust_toolchain_repository_proxy](#rust_toolchain_repository_proxy)
+* [rust_toolchain_repository](#rust_toolchain_repository)
+* [rust_toolchain](#rust_toolchain)
+
+<a id="#rust_stdlib_filegroup"></a>
+
+## rust_stdlib_filegroup
+
+<pre>
+rust_stdlib_filegroup(<a href="#rust_stdlib_filegroup-name">name</a>, <a href="#rust_stdlib_filegroup-srcs">srcs</a>)
+</pre>
+
+A dedicated filegroup-like rule for Rust stdlib artifacts.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_stdlib_filegroup-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_stdlib_filegroup-srcs"></a>srcs |  The list of targets/files that are components of the rust-stdlib file group   | <a href="https://bazel.build/docs/build-ref.html#labels">List of labels</a> | required |  |
+
+
+<a id="#rust_toolchain"></a>
+
+## rust_toolchain
+
+<pre>
+rust_toolchain(<a href="#rust_toolchain-name">name</a>, <a href="#rust_toolchain-allocator_library">allocator_library</a>, <a href="#rust_toolchain-binary_ext">binary_ext</a>, <a href="#rust_toolchain-cargo">cargo</a>, <a href="#rust_toolchain-clippy_driver">clippy_driver</a>, <a href="#rust_toolchain-debug_info">debug_info</a>,
+               <a href="#rust_toolchain-default_edition">default_edition</a>, <a href="#rust_toolchain-dylib_ext">dylib_ext</a>, <a href="#rust_toolchain-exec_triple">exec_triple</a>, <a href="#rust_toolchain-llvm_tools">llvm_tools</a>, <a href="#rust_toolchain-opt_level">opt_level</a>, <a href="#rust_toolchain-os">os</a>, <a href="#rust_toolchain-rust_doc">rust_doc</a>, <a href="#rust_toolchain-rust_lib">rust_lib</a>,
+               <a href="#rust_toolchain-rust_std">rust_std</a>, <a href="#rust_toolchain-rustc">rustc</a>, <a href="#rust_toolchain-rustc_lib">rustc_lib</a>, <a href="#rust_toolchain-rustc_srcs">rustc_srcs</a>, <a href="#rust_toolchain-rustfmt">rustfmt</a>, <a href="#rust_toolchain-staticlib_ext">staticlib_ext</a>, <a href="#rust_toolchain-stdlib_linkflags">stdlib_linkflags</a>,
+               <a href="#rust_toolchain-target_json">target_json</a>, <a href="#rust_toolchain-target_triple">target_triple</a>)
+</pre>
+
+Declares a Rust toolchain for use.
+
+This is for declaring a custom toolchain, eg. for configuring a particular version of rust or supporting a new platform.
+
+Example:
+
+Suppose the core rust team has ported the compiler to a new target CPU, called `cpuX`. This support can be used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//rust:toolchain.bzl', 'rust_toolchain')
+
+rust_toolchain(
+    name = "rust_cpuX_impl",
+    rustc = "@rust_cpuX//:rustc",
+    rustc_lib = "@rust_cpuX//:rustc_lib",
+    rust_std = "@rust_cpuX//:rust_std",
+    rust_doc = "@rust_cpuX//:rustdoc",
+    binary_ext = "",
+    staticlib_ext = ".a",
+    dylib_ext = ".so",
+    stdlib_linkflags = ["-lpthread", "-ldl"],
+    os = "linux",
+)
+
+toolchain(
+    name = "rust_cpuX",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_cpuX_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to `register_toolchains` in the WORKSPACE, or pass it to the `"--extra_toolchains"` flag for Bazel, and it will be used.
+
+See @rules_rust//rust:repositories.bzl for examples of defining the @rust_cpuX repository with the actual binaries and libraries.
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain-allocator_library"></a>allocator_library |  Target that provides allocator functions when rust_library targets are embedded in a cc_binary.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-binary_ext"></a>binary_ext |  The extension for binaries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-cargo"></a>cargo |  The location of the <code>cargo</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-clippy_driver"></a>clippy_driver |  The location of the <code>clippy-driver</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-debug_info"></a>debug_info |  Rustc debug info levels per opt level   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {"dbg": "2", "fastbuild": "0", "opt": "0"} |
+| <a id="rust_toolchain-default_edition"></a>default_edition |  The edition to use for rust_* rules that don't specify an edition.   | String | optional | "2018" |
+| <a id="rust_toolchain-dylib_ext"></a>dylib_ext |  The extension for dynamic libraries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-exec_triple"></a>exec_triple |  The platform triple for the toolchains execution environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations   | String | required |  |
+| <a id="rust_toolchain-llvm_tools"></a>llvm_tools |  LLVM tools that are shipped with the Rust toolchain.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-opt_level"></a>opt_level |  Rustc optimization levels.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {"dbg": "0", "fastbuild": "0", "opt": "3"} |
+| <a id="rust_toolchain-os"></a>os |  The operating system for the current toolchain   | String | required |  |
+| <a id="rust_toolchain-rust_doc"></a>rust_doc |  The location of the <code>rustdoc</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_toolchain-rust_lib"></a>rust_lib |  **Deprecated**: Use <code>rust_std</code>   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rust_std"></a>rust_std |  The Rust standard library.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustc"></a>rustc |  The location of the <code>rustc</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+| <a id="rust_toolchain-rustc_lib"></a>rustc_lib |  The libraries used by rustc during compilation.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustc_srcs"></a>rustc_srcs |  The source code of rustc.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-rustfmt"></a>rustfmt |  The location of the <code>rustfmt</code> binary. Can be a direct source or a filegroup containing one item.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-staticlib_ext"></a>staticlib_ext |  The extension for static libraries created from rustc.   | String | required |  |
+| <a id="rust_toolchain-stdlib_linkflags"></a>stdlib_linkflags |  Additional linker flags to use when Rust standard library is linked by a C++ linker (rustc will deal with these automatically). Subject to location expansion with respect to the srcs of the <code>rust_std</code> attribute.   | List of strings | required |  |
+| <a id="rust_toolchain-target_json"></a>target_json |  Override the target_triple with a custom target specification. For more details see: https://doc.rust-lang.org/rustc/targets/custom.html   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+| <a id="rust_toolchain-target_triple"></a>target_triple |  The platform triple for the toolchains target environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations   | String | optional | "" |
+
+
+<a id="#rust_toolchain_repository"></a>
+
+## rust_toolchain_repository
+
+<pre>
+rust_toolchain_repository(<a href="#rust_toolchain_repository-name">name</a>, <a href="#rust_toolchain_repository-auth">auth</a>, <a href="#rust_toolchain_repository-dev_components">dev_components</a>, <a href="#rust_toolchain_repository-edition">edition</a>, <a href="#rust_toolchain_repository-exec_triple">exec_triple</a>, <a href="#rust_toolchain_repository-extra_target_triples">extra_target_triples</a>,
+                          <a href="#rust_toolchain_repository-include_rustc_srcs">include_rustc_srcs</a>, <a href="#rust_toolchain_repository-iso_date">iso_date</a>, <a href="#rust_toolchain_repository-repo_mapping">repo_mapping</a>, <a href="#rust_toolchain_repository-rustfmt_version">rustfmt_version</a>, <a href="#rust_toolchain_repository-sha256s">sha256s</a>,
+                          <a href="#rust_toolchain_repository-toolchain_name_prefix">toolchain_name_prefix</a>, <a href="#rust_toolchain_repository-urls">urls</a>, <a href="#rust_toolchain_repository-version">version</a>)
+</pre>
+
+Composes a single workspace containing the toolchain components for compiling on a given platform to a series of target platforms.
+
+A given instance of this rule should be accompanied by a rust_toolchain_repository_proxy invocation to declare its toolchains to Bazel; the indirection allows separating toolchain selection from toolchain fetching.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain_repository-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain_repository-auth"></a>auth |  Auth object compatible with repository_ctx.download to use when downloading files. See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_toolchain_repository-dev_components"></a>dev_components |  Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly".   | Boolean | optional | False |
+| <a id="rust_toolchain_repository-edition"></a>edition |  The rust edition to be used by default.   | String | optional | "2018" |
+| <a id="rust_toolchain_repository-exec_triple"></a>exec_triple |  The Rust-style target that this compiler runs on   | String | required |  |
+| <a id="rust_toolchain_repository-extra_target_triples"></a>extra_target_triples |  Additional rust-style targets that this set of toolchains should support.   | List of strings | optional | [] |
+| <a id="rust_toolchain_repository-include_rustc_srcs"></a>include_rustc_srcs |  Whether to download and unpack the rustc source files. These are very large, and slow to unpack, but are required to support rust analyzer. An environment variable <code>RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS</code> can also be used to control this attribute. This variable will take precedence over the hard coded attribute. Setting it to <code>true</code> to activates this attribute where all other values deactivate it.   | Boolean | optional | False |
+| <a id="rust_toolchain_repository-iso_date"></a>iso_date |  The date of the tool (or None, if the version is a specific version).   | String | optional | "" |
+| <a id="rust_toolchain_repository-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="rust_toolchain_repository-rustfmt_version"></a>rustfmt_version |  The version of the tool among "nightly", "beta", or an exact version.   | String | optional | "" |
+| <a id="rust_toolchain_repository-sha256s"></a>sha256s |  A dict associating tool subdirectories to sha256 hashes. See [rust_repositories](#rust_repositories) for more details.   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | optional | {} |
+| <a id="rust_toolchain_repository-toolchain_name_prefix"></a>toolchain_name_prefix |  The per-target prefix expected for the rust_toolchain declarations in the parent workspace.   | String | optional | "" |
+| <a id="rust_toolchain_repository-urls"></a>urls |  A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format).   | List of strings | optional | ["https://static.rust-lang.org/dist/{}.tar.gz"] |
+| <a id="rust_toolchain_repository-version"></a>version |  The version of the tool among "nightly", "beta", or an exact version.   | String | required |  |
+
+
+<a id="#rust_toolchain_repository_proxy"></a>
+
+## rust_toolchain_repository_proxy
+
+<pre>
+rust_toolchain_repository_proxy(<a href="#rust_toolchain_repository_proxy-name">name</a>, <a href="#rust_toolchain_repository_proxy-exec_triple">exec_triple</a>, <a href="#rust_toolchain_repository_proxy-extra_target_triples">extra_target_triples</a>, <a href="#rust_toolchain_repository_proxy-parent_workspace_name">parent_workspace_name</a>,
+                                <a href="#rust_toolchain_repository_proxy-repo_mapping">repo_mapping</a>, <a href="#rust_toolchain_repository_proxy-toolchain_name_prefix">toolchain_name_prefix</a>)
+</pre>
+
+Generates a toolchain-bearing repository that declares the toolchains from some other rust_toolchain_repository.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_toolchain_repository_proxy-name"></a>name |  A unique name for this repository.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_toolchain_repository_proxy-exec_triple"></a>exec_triple |  The Rust-style target triple for the compilation platform   | String | required |  |
+| <a id="rust_toolchain_repository_proxy-extra_target_triples"></a>extra_target_triples |  The Rust-style triples for extra compilation targets   | List of strings | optional | [] |
+| <a id="rust_toolchain_repository_proxy-parent_workspace_name"></a>parent_workspace_name |  The name of the other rust_toolchain_repository   | String | required |  |
+| <a id="rust_toolchain_repository_proxy-repo_mapping"></a>repo_mapping |  A dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.&lt;p&gt;For example, an entry <code>"@foo": "@bar"</code> declares that, for any time this repository depends on <code>@foo</code> (such as a dependency on <code>@foo//some:target</code>, it should actually resolve that dependency within globally-declared <code>@bar</code> (<code>@bar//some:target</code>).   | <a href="https://bazel.build/docs/skylark/lib/dict.html">Dictionary: String -> String</a> | required |  |
+| <a id="rust_toolchain_repository_proxy-toolchain_name_prefix"></a>toolchain_name_prefix |  The per-target prefix expected for the rust_toolchain declarations in the parent workspace.   | String | optional | "" |
+
+
+<a id="#rust_repositories"></a>
+
+## rust_repositories
+
+<pre>
+rust_repositories(<a href="#rust_repositories-kwargs">kwargs</a>)
+</pre>
+
+**Deprecated**: Use [rules_rust_dependencies](#rules_rust_dependencies)     and [rust_register_toolchains](#rust_register_toolchains) directly.
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_repositories-kwargs"></a>kwargs |  Keyword arguments for the <code>rust_register_toolchains</code> macro.   |  none |
+
+
+<a id="#rust_repository_set"></a>
+
+## rust_repository_set
+
+<pre>
+rust_repository_set(<a href="#rust_repository_set-name">name</a>, <a href="#rust_repository_set-version">version</a>, <a href="#rust_repository_set-exec_triple">exec_triple</a>, <a href="#rust_repository_set-include_rustc_srcs">include_rustc_srcs</a>, <a href="#rust_repository_set-extra_target_triples">extra_target_triples</a>, <a href="#rust_repository_set-iso_date">iso_date</a>,
+                    <a href="#rust_repository_set-rustfmt_version">rustfmt_version</a>, <a href="#rust_repository_set-edition">edition</a>, <a href="#rust_repository_set-dev_components">dev_components</a>, <a href="#rust_repository_set-sha256s">sha256s</a>, <a href="#rust_repository_set-urls">urls</a>, <a href="#rust_repository_set-auth">auth</a>, <a href="#rust_repository_set-register_toolchain">register_toolchain</a>)
+</pre>
+
+Assembles a remote repository for the given toolchain params, produces a proxy repository     to contain the toolchain declaration, and registers the toolchains.
+
+N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints)     without actually downloading the toolchain.
+
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_repository_set-name"></a>name |  The name of the generated repository   |  none |
+| <a id="rust_repository_set-version"></a>version |  The version of the tool among "nightly", "beta', or an exact version.   |  none |
+| <a id="rust_repository_set-exec_triple"></a>exec_triple |  The Rust-style target that this compiler runs on   |  none |
+| <a id="rust_repository_set-include_rustc_srcs"></a>include_rustc_srcs |  Whether to download rustc's src code. This is required in order to use rust-analyzer support. Defaults to False.   |  <code>False</code> |
+| <a id="rust_repository_set-extra_target_triples"></a>extra_target_triples |  Additional rust-style targets that this set of toolchains should support. Defaults to [].   |  <code>[]</code> |
+| <a id="rust_repository_set-iso_date"></a>iso_date |  The date of the tool. Defaults to None.   |  <code>None</code> |
+| <a id="rust_repository_set-rustfmt_version"></a>rustfmt_version |  The version of rustfmt to be associated with the toolchain. Defaults to None.   |  <code>None</code> |
+| <a id="rust_repository_set-edition"></a>edition |  The rust edition to be used by default (2015, 2018 (if None), or 2021).   |  <code>None</code> |
+| <a id="rust_repository_set-dev_components"></a>dev_components |  Whether to download the rustc-dev components. Requires version to be "nightly". Defaults to False.   |  <code>False</code> |
+| <a id="rust_repository_set-sha256s"></a>sha256s |  A dict associating tool subdirectories to sha256 hashes. See [rust_repositories](#rust_repositories) for more details.   |  <code>None</code> |
+| <a id="rust_repository_set-urls"></a>urls |  A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). Defaults to ['https://static.rust-lang.org/dist/{}.tar.gz']   |  <code>["https://static.rust-lang.org/dist/{}.tar.gz"]</code> |
+| <a id="rust_repository_set-auth"></a>auth |  Auth object compatible with repository_ctx.download to use when downloading files. See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details.   |  <code>None</code> |
+| <a id="rust_repository_set-register_toolchain"></a>register_toolchain |  If True, the generated <code>rust_toolchain</code> target will become a registered toolchain.   |  <code>True</code> |
+
+
diff --git a/third_party/rules_rust/docs/rust_wasm_bindgen.md b/third_party/rules_rust/docs/rust_wasm_bindgen.md
new file mode 100644
index 0000000..be7dcf0
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_wasm_bindgen.md
@@ -0,0 +1,129 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Rust Wasm Bindgen
+
+* [rust_wasm_bindgen_repositories](#rust_wasm_bindgen_repositories)
+* [rust_wasm_bindgen_toolchain](#rust_wasm_bindgen_toolchain)
+* [rust_wasm_bindgen](#rust_wasm_bindgen)
+
+
+## Overview
+
+To build a `rust_binary` for `wasm32-unknown-unknown` target add the `--platforms=@rules_rust//rust/platform:wasm` flag.
+
+```command
+bazel build @examples//hello_world_wasm --platforms=@rules_rust//rust/platform:wasm
+```
+
+To build a `rust_binary` for `wasm32-wasi` target add the `--platforms=@rules_rust//rust/platform:wasi` flag.
+
+```command
+bazel build @examples//hello_world_wasm --platforms=@rules_rust//rust/platform:wasi
+```
+
+`rust_wasm_bindgen` will automatically transition to the `wasm` platform and can be used when
+building WebAssembly code for the host target.
+
+
+<a id="#rust_wasm_bindgen"></a>
+
+## rust_wasm_bindgen
+
+<pre>
+rust_wasm_bindgen(<a href="#rust_wasm_bindgen-name">name</a>, <a href="#rust_wasm_bindgen-bindgen_flags">bindgen_flags</a>, <a href="#rust_wasm_bindgen-target">target</a>, <a href="#rust_wasm_bindgen-wasm_file">wasm_file</a>)
+</pre>
+
+Generates javascript and typescript bindings for a webassembly module using [wasm-bindgen][ws].
+
+[ws]: https://rustwasm.github.io/docs/wasm-bindgen/
+
+To use the Rust WebAssembly bindgen rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust bindgen toolchain (in addition to the Rust rules setup):
+
+```python
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+```
+
+For more details on `rust_wasm_bindgen_repositories`, see [here](#rust_wasm_bindgen_repositories).
+
+An example of this rule in use can be seen at [@rules_rust//examples/wasm](../examples/wasm)
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_wasm_bindgen-bindgen_flags"></a>bindgen_flags |  Flags to pass directly to the bindgen executable. See https://github.com/rustwasm/wasm-bindgen/ for details.   | List of strings | optional | [] |
+| <a id="rust_wasm_bindgen-target"></a>target |  The type of output to generate. See https://rustwasm.github.io/wasm-bindgen/reference/deployment.html for details.   | String | optional | "bundler" |
+| <a id="rust_wasm_bindgen-wasm_file"></a>wasm_file |  The <code>.wasm</code> file or crate to generate bindings for.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | required |  |
+
+
+<a id="#rust_wasm_bindgen_toolchain"></a>
+
+## rust_wasm_bindgen_toolchain
+
+<pre>
+rust_wasm_bindgen_toolchain(<a href="#rust_wasm_bindgen_toolchain-name">name</a>, <a href="#rust_wasm_bindgen_toolchain-bindgen">bindgen</a>)
+</pre>
+
+The tools required for the `rust_wasm_bindgen` rule.
+
+In cases where users want to control or change the version of `wasm-bindgen` used by [rust_wasm_bindgen](#rust_wasm_bindgen),
+a unique toolchain can be created as in the example below:
+
+```python
+load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_toolchain")
+
+rust_bindgen_toolchain(
+    bindgen = "//my/cargo_raze:cargo_bin_wasm_bindgen",
+)
+
+toolchain(
+    name = "wasm_bindgen_toolchain",
+    toolchain = "wasm_bindgen_toolchain_impl",
+    toolchain_type = "@rules_rust//wasm_bindgen:wasm_bindgen_toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:wasm_bindgen_toolchain")
+```
+
+For additional information, see the [Bazel toolchains documentation][toolchains].
+
+[toolchains]: https://docs.bazel.build/versions/master/toolchains.html
+
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen_toolchain-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="rust_wasm_bindgen_toolchain-bindgen"></a>bindgen |  The label of a <code>wasm-bindgen-cli</code> executable.   | <a href="https://bazel.build/docs/build-ref.html#labels">Label</a> | optional | None |
+
+
+<a id="#rust_wasm_bindgen_repositories"></a>
+
+## rust_wasm_bindgen_repositories
+
+<pre>
+rust_wasm_bindgen_repositories(<a href="#rust_wasm_bindgen_repositories-register_default_toolchain">register_default_toolchain</a>)
+</pre>
+
+Declare dependencies needed for [rust_wasm_bindgen](#rust_wasm_bindgen).
+
+**PARAMETERS**
+
+
+| Name  | Description | Default Value |
+| :------------- | :------------- | :------------- |
+| <a id="rust_wasm_bindgen_repositories-register_default_toolchain"></a>register_default_toolchain |  If True, the default [rust_wasm_bindgen_toolchain](#rust_wasm_bindgen_toolchain) (<code>@rules_rust//wasm_bindgen:default_wasm_bindgen_toolchain</code>) is registered. This toolchain requires a set of dependencies that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.   |  <code>True</code> |
+
+
diff --git a/third_party/rules_rust/docs/rust_wasm_bindgen.vm b/third_party/rules_rust/docs/rust_wasm_bindgen.vm
new file mode 100644
index 0000000..13e78b1
--- /dev/null
+++ b/third_party/rules_rust/docs/rust_wasm_bindgen.vm
@@ -0,0 +1,18 @@
+#[[
+## Overview
+
+To build a `rust_binary` for `wasm32-unknown-unknown` target add the `--platforms=@rules_rust//rust/platform:wasm` flag.
+
+```command
+bazel build @examples//hello_world_wasm --platforms=@rules_rust//rust/platform:wasm
+```
+
+To build a `rust_binary` for `wasm32-wasi` target add the `--platforms=@rules_rust//rust/platform:wasi` flag.
+
+```command
+bazel build @examples//hello_world_wasm --platforms=@rules_rust//rust/platform:wasi
+```
+
+`rust_wasm_bindgen` will automatically transition to the `wasm` platform and can be used when
+building WebAssembly code for the host target.
+]]#
diff --git a/third_party/rules_rust/docs/settings.md b/third_party/rules_rust/docs/settings.md
new file mode 100644
index 0000000..4605272
--- /dev/null
+++ b/third_party/rules_rust/docs/settings.md
@@ -0,0 +1,25 @@
+<!-- Generated with Stardoc: http://skydoc.bazel.build -->
+# Settings
+
+* [incompatible_flag](#incompatible_flag)
+* [fail_when_enabled](#fail_when_enabled)
+
+<a id="#incompatible_flag"></a>
+
+## incompatible_flag
+
+<pre>
+incompatible_flag(<a href="#incompatible_flag-name">name</a>, <a href="#incompatible_flag-issue">issue</a>)
+</pre>
+
+A rule defining an incompatible flag.
+
+**ATTRIBUTES**
+
+
+| Name  | Description | Type | Mandatory | Default |
+| :------------- | :------------- | :------------- | :------------- | :------------- |
+| <a id="incompatible_flag-name"></a>name |  A unique name for this target.   | <a href="https://bazel.build/docs/build-ref.html#name">Name</a> | required |  |
+| <a id="incompatible_flag-issue"></a>issue |  The link to the github issue associated with this flag   | String | required |  |
+
+
diff --git a/third_party/rules_rust/docs/symbols.bzl b/third_party/rules_rust/docs/symbols.bzl
new file mode 100644
index 0000000..4427845
--- /dev/null
+++ b/third_party/rules_rust/docs/symbols.bzl
@@ -0,0 +1,155 @@
+"""This module provides a single place for all aspects, rules, and macros that are meant
+to have stardoc generated documentation.
+"""
+
+load(
+    "@rules_rust//bindgen:bindgen.bzl",
+    _rust_bindgen = "rust_bindgen",
+    _rust_bindgen_library = "rust_bindgen_library",
+    _rust_bindgen_toolchain = "rust_bindgen_toolchain",
+)
+load(
+    "@rules_rust//bindgen:repositories.bzl",
+    _rust_bindgen_repositories = "rust_bindgen_repositories",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    _cargo_bootstrap_repository = "cargo_bootstrap_repository",
+    _cargo_build_script = "cargo_build_script",
+    _cargo_env = "cargo_env",
+)
+load(
+    "@rules_rust//crate_universe:defs.bzl",
+    _crate = "crate",
+    _crates_repository = "crates_repository",
+    _crates_vendor = "crates_vendor",
+)
+load(
+    "@rules_rust//proto:proto.bzl",
+    _rust_grpc_library = "rust_grpc_library",
+    _rust_proto_library = "rust_proto_library",
+)
+load(
+    "@rules_rust//proto:repositories.bzl",
+    _rust_proto_repositories = "rust_proto_repositories",
+)
+load(
+    "@rules_rust//proto:toolchain.bzl",
+    _rust_proto_toolchain = "rust_proto_toolchain",
+)
+load(
+    "@rules_rust//proto:transitive_repositories.bzl",
+    _rust_proto_transitive_repositories = "rust_proto_transitive_repositories",
+)
+load(
+    "@rules_rust//rust:defs.bzl",
+    _capture_clippy_output = "capture_clippy_output",
+    _error_format = "error_format",
+    _extra_rustc_flags = "extra_rustc_flags",
+    _rust_analyzer = "rust_analyzer",
+    _rust_analyzer_aspect = "rust_analyzer_aspect",
+    _rust_binary = "rust_binary",
+    _rust_clippy = "rust_clippy",
+    _rust_clippy_aspect = "rust_clippy_aspect",
+    _rust_doc = "rust_doc",
+    _rust_doc_test = "rust_doc_test",
+    _rust_library = "rust_library",
+    _rust_proc_macro = "rust_proc_macro",
+    _rust_shared_library = "rust_shared_library",
+    _rust_static_library = "rust_static_library",
+    _rust_test = "rust_test",
+    _rust_test_suite = "rust_test_suite",
+    _rustfmt_aspect = "rustfmt_aspect",
+    _rustfmt_test = "rustfmt_test",
+)
+load(
+    "@rules_rust//rust:repositories.bzl",
+    _rust_repositories = "rust_repositories",
+    _rust_repository_set = "rust_repository_set",
+    _rust_toolchain_repository = "rust_toolchain_repository",
+    _rust_toolchain_repository_proxy = "rust_toolchain_repository_proxy",
+)
+load(
+    "@rules_rust//rust:toolchain.bzl",
+    _rust_stdlib_filegroup = "rust_stdlib_filegroup",
+    _rust_toolchain = "rust_toolchain",
+)
+
+# buildifier: disable=bzl-visibility
+load(
+    "@rules_rust//rust/private:providers.bzl",
+    _CrateInfo = "CrateInfo",
+    _DepInfo = "DepInfo",
+    _StdLibInfo = "StdLibInfo",
+)
+load(
+    "@rules_rust//rust/settings:incompatible.bzl",
+    _incompatible_flag = "incompatible_flag",
+)
+load(
+    "@rules_rust//wasm_bindgen:repositories.bzl",
+    _rust_wasm_bindgen_repositories = "rust_wasm_bindgen_repositories",
+)
+load(
+    "@rules_rust//wasm_bindgen:wasm_bindgen.bzl",
+    _rust_wasm_bindgen = "rust_wasm_bindgen",
+    _rust_wasm_bindgen_toolchain = "rust_wasm_bindgen_toolchain",
+)
+
+rust_binary = _rust_binary
+rust_library = _rust_library
+rust_static_library = _rust_static_library
+rust_shared_library = _rust_shared_library
+rust_proc_macro = _rust_proc_macro
+rust_test = _rust_test
+rust_test_suite = _rust_test_suite
+rust_doc = _rust_doc
+rust_doc_test = _rust_doc_test
+
+rust_proto_library = _rust_proto_library
+rust_grpc_library = _rust_grpc_library
+
+rust_bindgen_toolchain = _rust_bindgen_toolchain
+rust_bindgen = _rust_bindgen
+rust_bindgen_library = _rust_bindgen_library
+rust_bindgen_repositories = _rust_bindgen_repositories
+
+rust_toolchain = _rust_toolchain
+rust_proto_toolchain = _rust_proto_toolchain
+rust_proto_repositories = _rust_proto_repositories
+rust_stdlib_filegroup = _rust_stdlib_filegroup
+rust_proto_transitive_repositories = _rust_proto_transitive_repositories
+
+cargo_build_script = _cargo_build_script
+cargo_bootstrap_repository = _cargo_bootstrap_repository
+cargo_env = _cargo_env
+
+rust_wasm_bindgen = _rust_wasm_bindgen
+rust_wasm_bindgen_toolchain = _rust_wasm_bindgen_toolchain
+rust_wasm_bindgen_repositories = _rust_wasm_bindgen_repositories
+
+rust_repositories = _rust_repositories
+rust_repository_set = _rust_repository_set
+rust_toolchain_repository = _rust_toolchain_repository
+rust_toolchain_repository_proxy = _rust_toolchain_repository_proxy
+
+rust_clippy = _rust_clippy
+rust_clippy_aspect = _rust_clippy_aspect
+rust_analyzer = _rust_analyzer
+rust_analyzer_aspect = _rust_analyzer_aspect
+
+crate = _crate
+crates_repository = _crates_repository
+crates_vendor = _crates_vendor
+
+rustfmt_aspect = _rustfmt_aspect
+rustfmt_test = _rustfmt_test
+
+error_format = _error_format
+extra_rustc_flags = _extra_rustc_flags
+incompatible_flag = _incompatible_flag
+capture_clippy_output = _capture_clippy_output
+
+CrateInfo = _CrateInfo
+DepInfo = _DepInfo
+StdLibInfo = _StdLibInfo
diff --git a/third_party/rules_rust/docs/test_docs.sh b/third_party/rules_rust/docs/test_docs.sh
new file mode 100755
index 0000000..f6677b9
--- /dev/null
+++ b/third_party/rules_rust/docs/test_docs.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -euo pipefail
+
+if [[ -n "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then
+    DOCS_WORKSPACE="${BUILD_WORKSPACE_DIRECTORY}"
+else
+    # Get the directory of the current script when not running under
+    # Bazel (as indicated by the lack of BUILD_WORKSPACE_DIRECTORY).
+    DOCS_WORKSPACE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+fi
+
+pushd "${DOCS_WORKSPACE}" &> /dev/null
+# It's important to clean the workspace so we don't end up with unintended
+# docs artifacts in the new commit.
+bazel clean \
+&& bazel build //... \
+&& cp bazel-bin/*.md . \
+&& chmod 0644 *.md
+
+if [ -n "$(git status --porcelain)" ]; then 
+    git status
+    echo '/docs is out of date. Please run `./docs/update_docs.sh` from the root of rules_rust and push the results' >&2
+    exit 1
+fi
+
+popd &> /dev/null
diff --git a/third_party/rules_rust/docs/update_docs.sh b/third_party/rules_rust/docs/update_docs.sh
new file mode 100755
index 0000000..94890eb
--- /dev/null
+++ b/third_party/rules_rust/docs/update_docs.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+set -euo pipefail
+
+if [[ -n "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then
+    DOCS_WORKSPACE="${BUILD_WORKSPACE_DIRECTORY}"
+else
+    # https://stackoverflow.com/a/246128/7768383
+    DOCS_WORKSPACE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+fi
+
+pushd "${DOCS_WORKSPACE}" &> /dev/null
+# It's important to clean the workspace so we don't end up with unintended
+# docs artifacts in the new commit.
+bazel clean \
+&& bazel build //... \
+&& cp bazel-bin/*.md . \
+&& chmod 0644 *.md
+
+if [[ -z "${SKIP_COMMIT:-}" ]]; then
+    git add *.md && git commit -m "Regenerate documentation"
+fi
+
+popd &> /dev/null
diff --git a/third_party/rules_rust/examples/.bazelignore b/third_party/rules_rust/examples/.bazelignore
new file mode 100644
index 0000000..65f8fb8
--- /dev/null
+++ b/third_party/rules_rust/examples/.bazelignore
@@ -0,0 +1,2 @@
+cargo_manifest_dir/external_crate
+crate_universe
diff --git a/third_party/rules_rust/examples/.bazelrc b/third_party/rules_rust/examples/.bazelrc
new file mode 100644
index 0000000..30c4a08
--- /dev/null
+++ b/third_party/rules_rust/examples/.bazelrc
@@ -0,0 +1,14 @@
+# `.bazelrc` is a Bazel configuration file.
+# https://bazel.build/docs/best-practices#bazelrc-file
+
+# Enable rustfmt for all targets in the workspace
+build:rustfmt --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:rustfmt --output_groups=+rustfmt_checks
+
+# Enable clippy for all targets in the workspace
+build:clippy --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:clippy --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/BUILD.bazel b/third_party/rules_rust/examples/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/BUILD.bazel
diff --git a/third_party/rules_rust/examples/WORKSPACE.bazel b/third_party/rules_rust/examples/WORKSPACE.bazel
new file mode 100644
index 0000000..47dec43
--- /dev/null
+++ b/third_party/rules_rust/examples/WORKSPACE.bazel
@@ -0,0 +1,126 @@
+workspace(name = "examples")
+
+# Users of `rules_rust` will commonly be unable to load it
+# using a `local_repository`. Instead, to setup the rules,
+# please see https://bazelbuild.github.io/rules_rust/#setup
+local_repository(
+    name = "rules_rust",
+    path = "..",
+)
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains(include_rustc_srcs = True)
+
+load("@rules_rust//bindgen:repositories.bzl", "rust_bindgen_repositories")
+
+rust_bindgen_repositories()
+
+load("@rules_rust//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+
+load("@rules_rust//proto:transitive_repositories.bzl", "rust_proto_transitive_repositories")
+
+rust_proto_transitive_repositories()
+
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+###############################################################################
+# Workspace examples
+###############################################################################
+
+# buildifier: disable=same-origin-load
+load("@rules_rust//rust:repositories.bzl", "rust_repository_set")
+
+# `rust_repository_set` is the core repository rule for downloading and defining
+# a rust_toolchain. Should there be a need for a customized toolchain, this macro can
+# be used to define and register one.
+rust_repository_set(
+    name = "fake_toolchain_for_test_of_sha256",
+    edition = "2018",
+    exec_triple = "x86_64-unknown-linux-gnu",
+    extra_target_triples = [],
+    rustfmt_version = "1.4.12",
+    sha256s = {
+        "rust-1.46.0-x86_64-unknown-linux-gnu": "e3b98bc3440fe92817881933f9564389eccb396f5f431f33d48b979fa2fbdcf5",
+        "rust-std-1.46.0-x86_64-unknown-linux-gnu": "ac04aef80423f612c0079829b504902de27a6997214eb58ab0765d02f7ec1dbc",
+        "rustfmt-1.4.12-x86_64-unknown-linux-gnu": "1894e76913303d66bf40885a601462844eec15fca9e76a6d13c390d7000d64b0",
+    },
+    version = "1.46.0",
+)
+
+###############################################################################
+# Examples dependencies
+###############################################################################
+
+load("@build_bazel_rules_nodejs//:index.bzl", "node_repositories")
+
+node_repositories()
+
+http_archive(
+    name = "rules_foreign_cc",
+    sha256 = "69023642d5781c68911beda769f91fcbc8ca48711db935a75da7f6536b65047f",
+    strip_prefix = "rules_foreign_cc-0.6.0",
+    url = "https://github.com/bazelbuild/rules_foreign_cc/archive/0.6.0.tar.gz",
+)
+
+load("@rules_foreign_cc//foreign_cc:repositories.bzl", "rules_foreign_cc_dependencies")
+
+rules_foreign_cc_dependencies()
+
+load("//sys:sys_deps.bzl", "sys_deps")
+
+sys_deps()
+
+local_repository(
+    name = "rules_rust_example_cargo_manifest_dir",
+    path = "cargo_manifest_dir/external_crate",
+)
+
+_LIBC_BUILD_FILE_CONTENT = """\
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "libc",
+    srcs = glob(["src/**/*.rs"]),
+    edition = "2015",
+    visibility = ["//visibility:public"],
+)
+"""
+
+http_archive(
+    name = "libc",
+    build_file_content = _LIBC_BUILD_FILE_CONTENT,
+    sha256 = "1ac4c2ac6ed5a8fb9020c166bc63316205f1dc78d4b964ad31f4f21eb73f0c6d",
+    strip_prefix = "libc-0.2.20",
+    urls = [
+        "https://mirror.bazel.build/github.com/rust-lang/libc/archive/0.2.20.zip",
+        "https://github.com/rust-lang/libc/archive/0.2.20.zip",
+    ],
+)
+
+###############################################################################
+
+http_archive(
+    name = "bazel_toolchains",
+    sha256 = "179ec02f809e86abf56356d8898c8bd74069f1bd7c56044050c2cd3d79d0e024",
+    strip_prefix = "bazel-toolchains-4.1.0",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/releases/download/4.1.0/bazel-toolchains-4.1.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-toolchains/releases/download/4.1.0/bazel-toolchains-4.1.0.tar.gz",
+    ],
+)
+
+load("@bazel_toolchains//rules:rbe_repo.bzl", "rbe_autoconfig")
+
+# Creates a default toolchain config for RBE.
+# Use this as is if you are using the rbe_ubuntu16_04 container,
+# otherwise refer to RBE docs.
+rbe_autoconfig(name = "buildkite_config")
diff --git a/third_party/rules_rust/examples/ambiguous_deps/BUILD.bazel b/third_party/rules_rust/examples/ambiguous_deps/BUILD.bazel
new file mode 100644
index 0000000..0cf4b47
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/BUILD.bazel
@@ -0,0 +1,40 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+# A rust_binary that depends on two native libs with the same name.
+# See https://github.com/bazelbuild/rules_rust/issues/840.
+rust_binary(
+    name = "bin_with_same_name_deps",
+    srcs = ["bin.rs"],
+    deps = [
+        "//ambiguous_deps/x:exc",
+        "//ambiguous_deps/y:exc",
+    ],
+)
+
+# A rust_binary that depends on a native library with a name that doesn't
+# match the `lib<name>.a` pattern on linux.
+rust_binary(
+    name = "nonstandard_name_bin",
+    srcs = ["nonstandard_name_bin.rs"],
+    deps = [":nonstandard_name_intermediate"],
+)
+
+cc_library(
+    name = "nonstandard_name_cc_lib",
+    srcs = ["cc_library_with_func.cc"],
+)
+
+genrule(
+    name = "nonstandard_name_gen",
+    srcs = [":nonstandard_name_cc_lib"],
+    outs = ["nonstandard_name_gen.a"],
+    # Copy the first member (libnonstandard_name_cc_lib.a) from the srcs to the
+    # output nonstandard_name_gen.a.
+    cmd = "cp $$(awk '{print $$1}' <<< '$(SRCS)') $@",
+)
+
+cc_library(
+    name = "nonstandard_name_intermediate",
+    srcs = [":nonstandard_name_gen.a"],
+)
diff --git a/third_party/rules_rust/examples/ambiguous_deps/bin.rs b/third_party/rules_rust/examples/ambiguous_deps/bin.rs
new file mode 100644
index 0000000..8f69444
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/bin.rs
@@ -0,0 +1,10 @@
+use std::os::raw::c_int;
+
+extern "C" {
+    pub fn cx() -> c_int;
+    pub fn cy() -> c_int;
+}
+
+fn main() {
+    println!("hi {} {}", unsafe { cx() }, unsafe { cy() });
+}
diff --git a/third_party/rules_rust/examples/ambiguous_deps/cc_library_with_func.cc b/third_party/rules_rust/examples/ambiguous_deps/cc_library_with_func.cc
new file mode 100644
index 0000000..536fa93
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/cc_library_with_func.cc
@@ -0,0 +1,3 @@
+extern "C" int func() {
+  return 123;
+}
diff --git a/third_party/rules_rust/examples/ambiguous_deps/nonstandard_name_bin.rs b/third_party/rules_rust/examples/ambiguous_deps/nonstandard_name_bin.rs
new file mode 100644
index 0000000..2c07702
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/nonstandard_name_bin.rs
@@ -0,0 +1,9 @@
+use std::os::raw::c_int;
+
+extern "C" {
+    pub fn func() -> c_int;
+}
+
+fn main() {
+    println!("hi {}", unsafe { func() });
+}
diff --git a/third_party/rules_rust/examples/ambiguous_deps/x/BUILD.bazel b/third_party/rules_rust/examples/ambiguous_deps/x/BUILD.bazel
new file mode 100644
index 0000000..87ae07c
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/x/BUILD.bazel
@@ -0,0 +1,7 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "exc",
+    srcs = ["exc.cc"],
+    visibility = ["//ambiguous_deps:__subpackages__"],
+)
diff --git a/third_party/rules_rust/examples/ambiguous_deps/x/exc.cc b/third_party/rules_rust/examples/ambiguous_deps/x/exc.cc
new file mode 100644
index 0000000..2b67c34
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/x/exc.cc
@@ -0,0 +1 @@
+extern "C" int cx() { return 17; }
diff --git a/third_party/rules_rust/examples/ambiguous_deps/y/BUILD.bazel b/third_party/rules_rust/examples/ambiguous_deps/y/BUILD.bazel
new file mode 100644
index 0000000..87ae07c
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/y/BUILD.bazel
@@ -0,0 +1,7 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "exc",
+    srcs = ["exc.cc"],
+    visibility = ["//ambiguous_deps:__subpackages__"],
+)
diff --git a/third_party/rules_rust/examples/ambiguous_deps/y/exc.cc b/third_party/rules_rust/examples/ambiguous_deps/y/exc.cc
new file mode 100644
index 0000000..903ed08
--- /dev/null
+++ b/third_party/rules_rust/examples/ambiguous_deps/y/exc.cc
@@ -0,0 +1 @@
+extern "C" int cy() { return 113; }
diff --git a/third_party/rules_rust/examples/bindgen/BUILD.bazel b/third_party/rules_rust/examples/bindgen/BUILD.bazel
new file mode 100644
index 0000000..1a62c78
--- /dev/null
+++ b/third_party/rules_rust/examples/bindgen/BUILD.bazel
@@ -0,0 +1,52 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_library")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
+
+cc_library(
+    name = "simple",
+    srcs = ["simple.h"],
+)
+
+rust_bindgen_library(
+    name = "simple_bindgen",
+    bindgen_flags = [
+        "--allowlist-var=SIMPLE_.*",
+    ],
+    cc_lib = ":simple",
+    header = "simple.h",
+)
+
+rust_binary(
+    name = "simple_example",
+    srcs = ["main.rs"],
+    deps = [":simple_bindgen"],
+)
+
+rust_test(
+    name = "simple_test",
+    crate = ":simple_example",
+)
+
+# Same as above, except disabling formatting on bindgen.
+rust_bindgen_library(
+    name = "simple_bindgen_unformatted",
+    bindgen_flags = [
+        "--allowlist-var=SIMPLE_.*",
+    ],
+    cc_lib = ":simple",
+    crate_name = "simple_bindgen",
+    header = "simple.h",
+    rustfmt = False,
+)
+
+rust_binary(
+    name = "simple_example_unformatted",
+    srcs = ["main.rs"],
+    crate_name = "simple_example",
+    deps = [":simple_bindgen_unformatted"],
+)
+
+rust_test(
+    name = "simple_test_unformatted",
+    crate = ":simple_example_unformatted",
+)
diff --git a/third_party/rules_rust/examples/bindgen/main.rs b/third_party/rules_rust/examples/bindgen/main.rs
new file mode 100644
index 0000000..fb93ce4
--- /dev/null
+++ b/third_party/rules_rust/examples/bindgen/main.rs
@@ -0,0 +1,11 @@
+fn main() {
+    println!("The value is {}!", simple_bindgen::SIMPLE_VALUE);
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn do_the_test() {
+        assert_eq!(42, simple_bindgen::SIMPLE_VALUE);
+    }
+}
diff --git a/third_party/rules_rust/examples/bindgen/simple.h b/third_party/rules_rust/examples/bindgen/simple.h
new file mode 100644
index 0000000..072f9ea
--- /dev/null
+++ b/third_party/rules_rust/examples/bindgen/simple.h
@@ -0,0 +1,3 @@
+#include <stdint.h>
+
+const int64_t SIMPLE_VALUE = 42;
diff --git a/third_party/rules_rust/examples/cargo/BUILD.bazel b/third_party/rules_rust/examples/cargo/BUILD.bazel
new file mode 100644
index 0000000..463841f
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo/BUILD.bazel
@@ -0,0 +1,24 @@
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+cargo_build_script(
+    name = "build_script",
+    srcs = ["build_script.rs"],
+    build_script_env = {"SOME_ENV": "42"},
+    crate_features = ["bleh"],
+    data = ["test.txt"],
+)
+
+rust_library(
+    name = "lib",
+    srcs = ["lib.rs"],
+    deps = [":build_script"],
+)
+
+rust_test(
+    name = "test",
+    crate = ":lib",
+)
diff --git a/third_party/rules_rust/examples/cargo/build_script.rs b/third_party/rules_rust/examples/cargo/build_script.rs
new file mode 100644
index 0000000..1ede7e3
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo/build_script.rs
@@ -0,0 +1,35 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+use std::env;
+use std::fs::File;
+use std::io::prelude::*;
+
+fn main() {
+    let bleh = env::var("CARGO_FEATURE_BLEH").unwrap();
+    let some_env = env::var("SOME_ENV").unwrap();
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let data = std::fs::read("test.txt").unwrap();
+    assert!(!bleh.is_empty());
+    assert_eq!(some_env, "42");
+    println!(
+        r#"cargo:rustc-env=FOO=BAR
+cargo:rustc-env=BAR=FOO
+cargo:rustc-flags=--cfg=blah="bleh"
+cargo:rustc-flags=--cfg=data="{}"
+cargo:rustc-cfg=foobar"#,
+        std::str::from_utf8(&data).unwrap()
+    );
+    let mut file = File::create(format!("{}/hello.world.txt", out_dir)).unwrap();
+    file.write_all(b"Hello, world!").unwrap();
+}
diff --git a/third_party/rules_rust/examples/cargo/lib.rs b/third_party/rules_rust/examples/cargo/lib.rs
new file mode 100644
index 0000000..3bb21d3
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo/lib.rs
@@ -0,0 +1,39 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+// theoretically this should be safe, as unit tests are built without
+// optimizations
+#![allow(clippy::assertions_on_constants)]
+mod test {
+    #[test]
+    fn test_env_contents() {
+        assert_eq!(env!("FOO"), "BAR");
+        assert_eq!(env!("BAR"), "FOO");
+    }
+
+    #[test]
+    fn test_cfg_contents() {
+        assert!(cfg!(foobar));
+    }
+
+    #[test]
+    fn test_rustc_contents() {
+        assert!(cfg!(blah = "bleh"));
+    }
+
+    #[test]
+    fn test_access_data() {
+        assert!(cfg!(data = "Yeah!"));
+    }
+}
diff --git a/third_party/rules_rust/examples/cargo/test.txt b/third_party/rules_rust/examples/cargo/test.txt
new file mode 100644
index 0000000..2eda9ce
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo/test.txt
@@ -0,0 +1 @@
+Yeah!
\ No newline at end of file
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/BUILD.bazel b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/BUILD.bazel
new file mode 100644
index 0000000..ca5ab63
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/BUILD.bazel
@@ -0,0 +1,8 @@
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "external_crate",
+    srcs = ["src/lib.rs"],
+    data = ["include/included_file.rs.inc"],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/WORKSPACE.bazel b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/WORKSPACE.bazel
new file mode 100644
index 0000000..38395cc
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/WORKSPACE.bazel
@@ -0,0 +1,10 @@
+workspace(name = "rules_rust_example_cargo_manifest_dir")
+
+local_repository(
+    name = "rules_rust",
+    path = "../../../",
+)
+
+load("@rules_rust//rust:repositories.bzl", "rust_repositories")
+
+rust_repositories()
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/include/included_file.rs.inc b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/include/included_file.rs.inc
new file mode 100644
index 0000000..4091ebb
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/include/included_file.rs.inc
@@ -0,0 +1 @@
+I love veggies!
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/src/lib.rs b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/src/lib.rs
new file mode 100644
index 0000000..d453fdd
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/external_crate/src/lib.rs
@@ -0,0 +1,6 @@
+pub fn get_included_str() -> &'static str {
+    include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/include/included_file.rs.inc"
+    ))
+}
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/usage/BUILD.bazel b/third_party/rules_rust/examples/cargo_manifest_dir/usage/BUILD.bazel
new file mode 100644
index 0000000..c88ccb7
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/usage/BUILD.bazel
@@ -0,0 +1,8 @@
+load("@rules_rust//rust:defs.bzl", "rust_test")
+
+rust_test(
+    name = "cargo_manifest_dir_usage",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    deps = ["@rules_rust_example_cargo_manifest_dir//:external_crate"],
+)
diff --git a/third_party/rules_rust/examples/cargo_manifest_dir/usage/src/lib.rs b/third_party/rules_rust/examples/cargo_manifest_dir/usage/src/lib.rs
new file mode 100644
index 0000000..20e902a
--- /dev/null
+++ b/third_party/rules_rust/examples/cargo_manifest_dir/usage/src/lib.rs
@@ -0,0 +1,6 @@
+use external_crate::get_included_str;
+
+#[test]
+fn test_lib_with_include() {
+    assert_eq!(get_included_str(), "I love veggies!\n")
+}
diff --git a/third_party/rules_rust/examples/crate_universe/.bazelrc b/third_party/rules_rust/examples/crate_universe/.bazelrc
new file mode 100644
index 0000000..30c4a08
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/.bazelrc
@@ -0,0 +1,14 @@
+# `.bazelrc` is a Bazel configuration file.
+# https://bazel.build/docs/best-practices#bazelrc-file
+
+# Enable rustfmt for all targets in the workspace
+build:rustfmt --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:rustfmt --output_groups=+rustfmt_checks
+
+# Enable clippy for all targets in the workspace
+build:clippy --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:clippy --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/.gitignore b/third_party/rules_rust/examples/crate_universe/.gitignore
new file mode 100644
index 0000000..ac51a05
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/.gitignore
@@ -0,0 +1 @@
+bazel-*
diff --git a/third_party/rules_rust/examples/crate_universe/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/BUILD.bazel
diff --git a/third_party/rules_rust/examples/crate_universe/README.md b/third_party/rules_rust/examples/crate_universe/README.md
new file mode 100644
index 0000000..df635b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/README.md
@@ -0,0 +1 @@
+# Examples
diff --git a/third_party/rules_rust/examples/crate_universe/WORKSPACE.bazel b/third_party/rules_rust/examples/crate_universe/WORKSPACE.bazel
new file mode 100644
index 0000000..40b4b08
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/WORKSPACE.bazel
@@ -0,0 +1,344 @@
+workspace(name = "examples")
+
+local_repository(
+    name = "rules_rust",
+    path = "../../",
+)
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains(include_rustc_srcs = True)
+
+load("@rules_rust//crate_universe:crates.bzl", "crate_deps_repository")
+
+crate_deps_repository()
+
+load("@rules_rust//crate_universe:crates_deps.bzl", "crate_repositories")
+
+crate_repositories()
+
+load("@rules_rust//crate_universe:defs.bzl", "crate", "crates_repository", "splicing_config")
+
+###############################################################################
+# C A R G O   A L I A S E S
+###############################################################################
+
+crates_repository(
+    name = "cargo_aliases",
+    annotations = {
+        "names": [crate.annotation(
+            shallow_since = "1646516410 -0700",
+            version = "0.12.1-dev",
+        )],
+    },
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//cargo_aliases:Cargo.Bazel.lock",
+    manifests = ["//cargo_aliases:Cargo.toml"],
+)
+
+load(
+    "@cargo_aliases//:defs.bzl",
+    cargo_aliases_crate_repositories = "crate_repositories",
+)
+
+cargo_aliases_crate_repositories()
+
+###############################################################################
+# C A R G O   L O C A L
+###############################################################################
+
+crates_repository(
+    name = "crate_index_cargo_local",
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//cargo_local:Cargo.lock",
+    lockfile_kind = "cargo",
+    manifests = ["//cargo_local:Cargo.toml"],
+)
+
+load(
+    "@crate_index_cargo_local//:defs.bzl",
+    cargo_local_crate_repositories = "crate_repositories",
+)
+
+cargo_local_crate_repositories()
+
+###############################################################################
+# C A R G O   R E M O T E
+###############################################################################
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "names",
+    build_file = "//cargo_remote:BUILD.names.bazel",
+    sha256 = "eab40caca5805624ba31d028913931c3d054b22daafff6f43e3435cfa9fb761e",
+    strip_prefix = "names-0.13.0",
+    urls = ["https://github.com/fnichol/names/archive/refs/tags/v0.13.0.zip"],
+)
+
+crates_repository(
+    name = "crate_index_cargo_remote",
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "@names//:Cargo.lock",
+    lockfile_kind = "cargo",
+    manifests = ["@names//:Cargo.toml"],
+)
+
+load(
+    "@crate_index_cargo_remote//:defs.bzl",
+    cargo_remote_crate_repositories = "crate_repositories",
+)
+
+cargo_remote_crate_repositories()
+
+###############################################################################
+# C A R G O   W O R K S P A C E
+###############################################################################
+
+crates_repository(
+    name = "crate_index_cargo_workspace",
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//cargo_workspace:Cargo.Bazel.lock",
+    manifests = [
+        "//cargo_workspace:Cargo.toml",
+        "//cargo_workspace/num_printer:Cargo.toml",
+        "//cargo_workspace/printer:Cargo.toml",
+        "//cargo_workspace/rng:Cargo.toml",
+    ],
+)
+
+load(
+    "@crate_index_cargo_workspace//:defs.bzl",
+    cargo_workspace_crate_repositories = "crate_repositories",
+)
+
+cargo_workspace_crate_repositories()
+
+###############################################################################
+# E X T R A   W O R K S P A C E   M E M B E R S
+###############################################################################
+
+crates_repository(
+    name = "crate_index_extra_members",
+    extra_workspace_members = {
+        "texture-synthesis-cli": crate.workspace_member(
+            sha256 = "a7dbdf13f5e6f214750fce1073279b71ce3076157a8d337c9b0f0e14334e2aec",
+            version = "0.8.2",
+        ),
+    },
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//extra_workspace_members:Cargo.Bazel.lock",
+    manifests = ["//extra_workspace_members:Cargo.toml"],
+)
+
+load(
+    "@crate_index_extra_members//:defs.bzl",
+    extra_workspace_members_crate_repositories = "crate_repositories",
+)
+
+extra_workspace_members_crate_repositories()
+
+###############################################################################
+# M U L T I   P A C K A G E
+###############################################################################
+
+crates_repository(
+    # The name here needs to be short to avoid long path issues on windows
+    # when running the `libnghttp2-sys` build script.
+    name = "m_pkgs",
+    annotations = {
+        "curl-sys": [crate.annotation(
+            gen_build_script = False,
+            deps = [
+                "@curl",
+                "@libssh2",
+            ],
+        )],
+        "lalrpop": [crate.annotation(
+            data_glob = ["**/*.lalrpop"],
+        )],
+        "libnghttp2-sys": [crate.annotation(
+            build_script_data_glob = ["nghttp2/**"],
+            data_glob = ["nghttp2/**"],
+        )],
+        "openssl-sys": [crate.annotation(
+            build_script_data = [
+                "@openssl//:gen_dir",
+                "@openssl//:openssl",
+            ],
+            build_script_data_glob = ["build/**/*.c"],
+            build_script_env = {
+                "OPENSSL_DIR": "$(execpath @openssl//:gen_dir)",
+                "OPENSSL_STATIC": "1",
+            },
+            data = ["@openssl"],
+            deps = ["@openssl"],
+        )],
+        "wepoll-ffi": [crate.annotation(
+            build_script_data_glob = ["vendor/**"],
+        )],
+    },
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//multi_package:Cargo.Bazel.lock",
+    manifests = [
+        "//multi_package/pkg_a:Cargo.toml",
+        "//multi_package/sub_pkgs/pkg_b:Cargo.toml",
+        "//multi_package/sub_pkgs/pkg_c:Cargo.toml",
+    ],
+)
+
+load(
+    "@m_pkgs//:defs.bzl",
+    multi_pkg_crate_repositories = "crate_repositories",
+)
+
+multi_pkg_crate_repositories()
+
+# ForeignCc is used to build OpenSSL
+http_archive(
+    name = "rules_foreign_cc",
+    sha256 = "1df78c7d7eed2dc21b8b325a2853c31933a81e7b780f9a59a5d078be9008b13a",
+    strip_prefix = "rules_foreign_cc-0.7.0",
+    url = "https://github.com/bazelbuild/rules_foreign_cc/archive/0.7.0.tar.gz",
+)
+
+load("@rules_foreign_cc//foreign_cc:repositories.bzl", "rules_foreign_cc_dependencies")
+
+rules_foreign_cc_dependencies()
+
+# Load OpenSSL and other 3rd party dependencies
+load("//multi_package/3rdparty:third_party_deps.bzl", "third_party_deps")
+
+third_party_deps()
+
+# perl is used to build openssl
+http_archive(
+    name = "rules_perl",
+    sha256 = "55fbe071971772758ad669615fc9aac9b126db6ae45909f0f36de499f6201dd3",
+    strip_prefix = "rules_perl-2f4f36f454375e678e81e5ca465d4d497c5c02da",
+    urls = [
+        "https://github.com/bazelbuild/rules_perl/archive/2f4f36f454375e678e81e5ca465d4d497c5c02da.tar.gz",
+    ],
+)
+
+load("@rules_perl//perl:deps.bzl", "perl_register_toolchains", "perl_rules_dependencies")
+
+perl_rules_dependencies()
+
+perl_register_toolchains()
+
+###############################################################################
+# N O   C A R G O   M A N I F E S T S
+###############################################################################
+
+crates_repository(
+    name = "no_cargo",
+    annotations = {
+        "axum": [crate.annotation(
+            compile_data_glob = ["**/*.md"],
+        )],
+    },
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    lockfile = "//no_cargo_manifests:Cargo.Bazel.lock",
+    packages = {
+        "axum": crate.spec(
+            version = "0.4.0",
+        ),
+        "hyper": crate.spec(
+            features = ["full"],
+            version = "0.14",
+        ),
+        "mime": crate.spec(
+            version = "0.3",
+        ),
+        "serde_json": crate.spec(
+            version = "1.0",
+        ),
+        "tokio": crate.spec(
+            features = ["full"],
+            version = "1.17.0",
+        ),
+        "tower": crate.spec(
+            features = ["util"],
+            version = "0.4",
+        ),
+        "tower-http": crate.spec(
+            features = ["trace"],
+            version = "0.2.1",
+        ),
+        "tracing": crate.spec(
+            version = "0.1",
+        ),
+        "tracing-subscriber": crate.spec(
+            version = "0.3",
+        ),
+    },
+    splicing_config = splicing_config(
+        resolver_version = "2",
+    ),
+)
+
+load(
+    "@no_cargo//:defs.bzl",
+    no_cargo_crate_repositories = "crate_repositories",
+)
+
+no_cargo_crate_repositories()
+
+###############################################################################
+# V E N D O R   R E M O T E   M A N I F E S T S
+###############################################################################
+
+load(
+    "//vendor_remote_manifests/crates:crates.bzl",
+    crates_vendor_manifests_repositories = "crate_repositories",
+)
+
+crates_vendor_manifests_repositories()
+
+###############################################################################
+# V E N D O R   R E M O T E   P A C K A G E S
+###############################################################################
+
+load(
+    "//vendor_remote_pkgs/crates:crates.bzl",
+    crates_vendor_packages_repositories = "crate_repositories",
+)
+
+crates_vendor_packages_repositories()
+
+###############################################################################
+
+# Used for Bazel CI
+http_archive(
+    name = "bazel_toolchains",
+    sha256 = "179ec02f809e86abf56356d8898c8bd74069f1bd7c56044050c2cd3d79d0e024",
+    strip_prefix = "bazel-toolchains-4.1.0",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/releases/download/4.1.0/bazel-toolchains-4.1.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-toolchains/releases/download/4.1.0/bazel-toolchains-4.1.0.tar.gz",
+    ],
+)
+
+load("@bazel_toolchains//rules:rbe_repo.bzl", "rbe_autoconfig")
+
+# Creates a default toolchain config for RBE.
+# Use this as is if you are using the rbe_ubuntu16_04 container,
+# otherwise refer to RBE docs.
+rbe_autoconfig(name = "buildkite_config")
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/.bazelrc b/third_party/rules_rust/examples/crate_universe/cargo_aliases/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_aliases/BUILD.bazel
new file mode 100644
index 0000000..3325478
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/BUILD.bazel
@@ -0,0 +1,26 @@
+load("@bazel_skylib//rules:build_test.bzl", "build_test")
+load("@cargo_aliases//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "aliases",
+    srcs = glob(["**/*.rs"]),
+    aliases = aliases(),
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    aliases = aliases(),
+    crate = ":aliases",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    deps = all_crate_deps(normal_dev = True),
+)
+
+# Ensures that Bazel aliases from the crates_repository are actually usable.
+build_test(
+    name = "names_build_test",
+    targets = ["@cargo_aliases//:names"],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.Bazel.lock b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.Bazel.lock
new file mode 100644
index 0000000..596b054
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.Bazel.lock
@@ -0,0 +1,2535 @@
+{
+  "checksum": "ba701df4681897610cd747b83f18fcb46468e975284b0ed0b596bcfaefe2a881",
+  "crates": {
+    "aho-corasick 0.7.18": {
+      "name": "aho-corasick",
+      "version": "0.7.18",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+          "sha256": "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "aho_corasick",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "aho_corasick",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.18"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "aliases 0.1.0": {
+      "name": "aliases",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "aliases",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "aliases",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.3.9",
+              "target": "log",
+              "alias": "pinned_log"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "names 0.12.1-dev",
+              "target": "names",
+              "alias": "pinned_names"
+            },
+            {
+              "id": "names 0.13.0",
+              "target": "names"
+            },
+            {
+              "id": "value-bag 1.0.0-alpha.7",
+              "target": "value_bag"
+            }
+          ],
+          "selects": {}
+        },
+        "deps_dev": {
+          "common": [
+            {
+              "id": "env_logger 0.9.0",
+              "target": "env_logger"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "atty 0.2.14": {
+      "name": "atty",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atty/0.2.14/download",
+          "sha256": "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atty",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atty",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"hermit\")": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "license": "MIT"
+    },
+    "autocfg 1.1.0": {
+      "name": "autocfg",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/autocfg/1.1.0/download",
+          "sha256": "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "autocfg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "autocfg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "clap 3.1.6": {
+      "name": "clap",
+      "version": "3.1.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap/3.1.6/download",
+          "sha256": "d8c93436c21e4698bacadf42917db28b23017027a4deccb35dbe47a7e7840123"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "clap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "atty",
+          "clap_derive",
+          "color",
+          "default",
+          "derive",
+          "lazy_static",
+          "std",
+          "strsim",
+          "suggestions",
+          "termcolor"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "indexmap"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "os_str_bytes 6.0.0",
+              "target": "os_str_bytes"
+            },
+            {
+              "id": "strsim 0.10.0",
+              "target": "strsim"
+            },
+            {
+              "id": "termcolor 1.1.3",
+              "target": "termcolor"
+            },
+            {
+              "id": "textwrap 0.15.0",
+              "target": "textwrap"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "clap_derive 3.1.4",
+              "target": "clap_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "3.1.6"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "clap_derive 3.1.4": {
+      "name": "clap_derive",
+      "version": "3.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap_derive/3.1.4/download",
+          "sha256": "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "clap_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "heck 0.4.0",
+              "target": "heck"
+            },
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "proc_macro_error"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "3.1.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "ctor 0.1.21": {
+      "name": "ctor",
+      "version": "0.1.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ctor/0.1.21/download",
+          "sha256": "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "ctor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ctor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.21"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "env_logger 0.9.0": {
+      "name": "env_logger",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/env_logger/0.9.0/download",
+          "sha256": "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "env_logger",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "env_logger",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "atty",
+          "default",
+          "humantime",
+          "regex",
+          "termcolor"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "humantime 2.1.0",
+              "target": "humantime"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "termcolor 1.1.3",
+              "target": "termcolor"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "getrandom 0.2.5": {
+      "name": "getrandom",
+      "version": "0.2.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/getrandom/0.2.5/download",
+          "sha256": "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "getrandom",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "getrandom",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"wasi\")": [
+              {
+                "id": "wasi 0.10.2+wasi-snapshot-preview1",
+                "target": "wasi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.2.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "hashbrown 0.11.2": {
+      "name": "hashbrown",
+      "version": "0.11.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hashbrown/0.11.2/download",
+          "sha256": "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hashbrown",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hashbrown",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "raw"
+        ],
+        "edition": "2018",
+        "version": "0.11.2"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "heck 0.4.0": {
+      "name": "heck",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/heck/0.4.0/download",
+          "sha256": "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "heck",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "heck",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "0.4.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "humantime 2.1.0": {
+      "name": "humantime",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/humantime/2.1.0/download",
+          "sha256": "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "humantime",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "humantime",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "2.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "indexmap 1.8.0": {
+      "name": "indexmap",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/indexmap/1.8.0/download",
+          "sha256": "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "indexmap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "indexmap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "hashbrown 0.11.2",
+              "target": "hashbrown"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "lazy_static 1.4.0": {
+      "name": "lazy_static",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+          "sha256": "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lazy_static",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lazy_static",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "log 0.3.9": {
+      "name": "log",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/log/0.3.9/download",
+          "sha256": "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "use_std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "log 0.4.14": {
+      "name": "log",
+      "version": "0.4.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/log/0.4.14/download",
+          "sha256": "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "memchr 2.4.1": {
+      "name": "memchr",
+      "version": "2.4.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+          "sha256": "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "memchr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "memchr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.4.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Unlicense/MIT"
+    },
+    "names 0.12.1-dev": {
+      "name": "names",
+      "version": "0.12.1-dev",
+      "repository": {
+        "Git": {
+          "remote": "https://github.com/fnichol/names.git",
+          "commitish": {
+            "Rev": "760516503b89ddc8bc2ab42d579d4566cfb1054f"
+          },
+          "shallow_since": "1646516410 -0700"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "names",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "names",
+            "crate_root": "src/bin/names.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "names",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "application",
+          "clap",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 3.1.6",
+              "target": "clap"
+            },
+            {
+              "id": "names 0.12.1-dev",
+              "target": "build_script_build"
+            },
+            {
+              "id": "rand 0.8.5",
+              "target": "rand"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.12.1-dev"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT"
+    },
+    "names 0.13.0": {
+      "name": "names",
+      "version": "0.13.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/names/0.13.0/download",
+          "sha256": "e7d66043b25d4a6cccb23619d10c19c25304b355a7dccd4a8e11423dd2382146"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "names",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "names",
+            "crate_root": "src/bin/names.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "names",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "application",
+          "clap",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 3.1.6",
+              "target": "clap"
+            },
+            {
+              "id": "names 0.13.0",
+              "target": "build_script_build"
+            },
+            {
+              "id": "rand 0.8.5",
+              "target": "rand"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.13.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT"
+    },
+    "os_str_bytes 6.0.0": {
+      "name": "os_str_bytes",
+      "version": "6.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/os_str_bytes/6.0.0/download",
+          "sha256": "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "os_str_bytes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "os_str_bytes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "memchr",
+          "raw_os_str"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "6.0.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "ppv-lite86 0.2.16": {
+      "name": "ppv-lite86",
+      "version": "0.2.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ppv-lite86/0.2.16/download",
+          "sha256": "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ppv_lite86",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ppv_lite86",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "simd",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.2.16"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "proc-macro-error 1.0.4": {
+      "name": "proc-macro-error",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error/1.0.4/download",
+          "sha256": "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro_error",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "syn",
+          "syn-error"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "proc_macro_error_attr"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro-error-attr 1.0.4": {
+      "name": "proc-macro-error-attr",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error-attr/1.0.4/download",
+          "sha256": "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "proc_macro_error_attr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error_attr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro2 1.0.36": {
+      "name": "proc-macro2",
+      "version": "1.0.36",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro2/1.0.36/download",
+          "sha256": "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.36"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "quote 1.0.15": {
+      "name": "quote",
+      "version": "1.0.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/quote/1.0.15/download",
+          "sha256": "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "quote",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "quote",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.15"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand 0.8.5": {
+      "name": "rand",
+      "version": "0.8.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand/0.8.5/download",
+          "sha256": "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "getrandom",
+          "libc",
+          "rand_chacha",
+          "std",
+          "std_rng"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_chacha 0.3.1",
+              "target": "rand_chacha"
+            },
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_chacha 0.3.1": {
+      "name": "rand_chacha",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_chacha/0.3.1/download",
+          "sha256": "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_chacha",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_chacha",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ppv-lite86 0.2.16",
+              "target": "ppv_lite86"
+            },
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_core 0.6.3": {
+      "name": "rand_core",
+      "version": "0.6.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.6.3/download",
+          "sha256": "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "getrandom",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "getrandom 0.2.5",
+              "target": "getrandom"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.6.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex 1.5.4": {
+      "name": "regex",
+      "version": "1.5.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex/1.5.4/download",
+          "sha256": "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "aho-corasick",
+          "memchr",
+          "perf",
+          "perf-cache",
+          "perf-dfa",
+          "perf-inline",
+          "perf-literal",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "aho-corasick 0.7.18",
+              "target": "aho_corasick"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "regex-syntax 0.6.25",
+              "target": "regex_syntax"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex-syntax 0.6.25": {
+      "name": "regex-syntax",
+      "version": "0.6.25",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+          "sha256": "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex_syntax",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex_syntax",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.6.25"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "strsim 0.10.0": {
+      "name": "strsim",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/strsim/0.10.0/download",
+          "sha256": "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "strsim",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "strsim",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "syn 1.0.86": {
+      "name": "syn",
+      "version": "1.0.86",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/syn/1.0.86/download",
+          "sha256": "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clone-impls",
+          "default",
+          "derive",
+          "full",
+          "parsing",
+          "printing",
+          "proc-macro",
+          "quote"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.86"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "termcolor 1.1.3": {
+      "name": "termcolor",
+      "version": "1.1.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/termcolor/1.1.3/download",
+          "sha256": "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "termcolor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "termcolor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.1.3"
+      },
+      "license": "Unlicense OR MIT"
+    },
+    "textwrap 0.15.0": {
+      "name": "textwrap",
+      "version": "0.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.15.0/download",
+          "sha256": "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.15.0"
+      },
+      "license": "MIT"
+    },
+    "unicode-xid 0.2.2": {
+      "name": "unicode-xid",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+          "sha256": "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_xid",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_xid",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "value-bag 1.0.0-alpha.7": {
+      "name": "value-bag",
+      "version": "1.0.0-alpha.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/value-bag/1.0.0-alpha.7/download",
+          "sha256": "dd320e1520f94261153e96f7534476ad869c14022aee1e59af7c778075d840ae"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "value_bag",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "value_bag",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "value-bag 1.0.0-alpha.7",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "ctor 0.1.21",
+              "target": "ctor"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.0-alpha.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check",
+              "alias": "rustc"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "version_check 0.9.4": {
+      "name": "version_check",
+      "version": "0.9.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/version_check/0.9.4/download",
+          "sha256": "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "version_check",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "version_check",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.9.4"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasi 0.10.2+wasi-snapshot-preview1": {
+      "name": "wasi",
+      "version": "0.10.2+wasi-snapshot-preview1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download",
+          "sha256": "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.10.2+wasi-snapshot-preview1"
+      },
+      "license": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "consoleapi",
+          "errhandlingapi",
+          "fileapi",
+          "minwinbase",
+          "minwindef",
+          "processenv",
+          "std",
+          "winbase",
+          "wincon",
+          "winerror",
+          "winnt"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-util 0.1.5": {
+      "name": "winapi-util",
+      "version": "0.1.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-util/0.1.5/download",
+          "sha256": "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.5"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    }
+  },
+  "binary_crates": [
+    "names 0.12.1-dev",
+    "names 0.13.0"
+  ],
+  "workspace_members": {
+    "aliases 0.1.0": "cargo_aliases"
+  },
+  "conditions": {
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"wasi\")": [
+      "wasm32-wasi"
+    ],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": []
+  }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.lock b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.lock
new file mode 100644
index 0000000..439c4d8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.lock
@@ -0,0 +1,404 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "aliases"
+version = "0.1.0"
+dependencies = [
+ "env_logger",
+ "log 0.3.9",
+ "log 0.4.14",
+ "names 0.12.1-dev",
+ "names 0.13.0",
+ "value-bag",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "3.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced1892c55c910c1219e98d6fc8d71f6bddba7905866ce740066d8bfea859312"
+dependencies = [
+ "atty",
+ "bitflags",
+ "clap_derive",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "strsim",
+ "termcolor",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da95d038ede1a964ce99f49cbe27a7fb538d1da595e4b4f70b8c8f338d17bf16"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log 0.4.14",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "indexmap"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+dependencies = [
+ "log 0.4.14",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "names"
+version = "0.12.1-dev"
+source = "git+https://github.com/fnichol/names.git?rev=760516503b89ddc8bc2ab42d579d4566cfb1054f#760516503b89ddc8bc2ab42d579d4566cfb1054f"
+dependencies = [
+ "clap",
+ "rand",
+]
+
+[[package]]
+name = "names"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7d66043b25d4a6cccb23619d10c19c25304b355a7dccd4a8e11423dd2382146"
+dependencies = [
+ "clap",
+ "rand",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "value-bag"
+version = "1.0.0-alpha.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd320e1520f94261153e96f7534476ad869c14022aee1e59af7c778075d840ae"
+dependencies = [
+ "ctor",
+ "version_check",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.toml
new file mode 100644
index 0000000..8a662c2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "aliases"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Defines library targets
+log = "=0.4.14"
+pinned_log = { package = "log", version = "=0.3.9" }
+
+# Contains a transitive alias
+value-bag = "=1.0.0-alpha.7"
+
+# Defines binary targets
+names = "=0.13.0"
+pinned_names = { package = "names", git = "https://github.com/fnichol/names.git", rev = "760516503b89ddc8bc2ab42d579d4566cfb1054f" }
+
+[dev-dependencies]
+env_logger = "0.9.0"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_aliases/src/lib.rs b/third_party/rules_rust/examples/crate_universe/cargo_aliases/src/lib.rs
new file mode 100644
index 0000000..6aa5199
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_aliases/src/lib.rs
@@ -0,0 +1,38 @@
+#[macro_use]
+extern crate pinned_log;
+
+use value_bag::ValueBag;
+
+pub fn new_log(text: &str) {
+    log::info!("new: {}", text);
+}
+
+pub fn pinned_log(text: &str) {
+    pinned_log::info!("old: {}", text);
+}
+
+pub fn value_bag() -> ValueBag<'static> {
+    ValueBag::capture_display(&42)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_logs() {
+        let _ = env_logger::builder().is_test(true).try_init();
+
+        new_log("text");
+        pinned_log("text");
+    }
+
+    #[test]
+    fn test_value_bag() {
+        let bag = value_bag();
+
+        let num = bag.to_u64().unwrap();
+
+        assert_eq!(42, num);
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_local/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_local/BUILD.bazel
new file mode 100644
index 0000000..0ed0ab6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_local/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@crate_index_cargo_local//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "cargo_local",
+    srcs = glob(["**/*.rs"]),
+    aliases = aliases(),
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":cargo_local",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.lock b/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.lock
new file mode 100644
index 0000000..6e94606
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.lock
@@ -0,0 +1,417 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "async-stream"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "171374e7e3b2504e0e5236e3b59260560f9fe94bfe9ac39ba5e4e929c5590625"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "648ed8c8d2ce5409ccd57453d9d1b214b342a0d69376a6feda1fd6cae3299308"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cargo_local"
+version = "0.1.0"
+dependencies = [
+ "tempfile",
+ "tokio",
+ "tokio-test",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "futures-core"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d1c26957f23603395cd326b0ffe64124b818f4449552f960d815cfba83a53d"
+
+[[package]]
+name = "getrandom"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "716d3d89f35ac6a34fd0eed635395f4c3b76fa889338a4632e5231a8684216bd"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
+
+[[package]]
+name = "lock_api"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "mio"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c2bdb6314ec10835cd3293dd268473a835c02b7b352e788be788b3c6ca6bb16"
+dependencies = [
+ "libc",
+ "log",
+ "miow",
+ "ntapi",
+ "winapi",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
+
+[[package]]
+name = "syn"
+version = "1.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5239bc68e0fef57495900cfea4e8dc75596d9a319d7e16b1e0a440d24e6fe0a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "tokio"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2c2416fdedca8443ae44b4527de1ea633af61d8f7169ffa6e72c5b53d24efcc"
+dependencies = [
+ "autocfg",
+ "bytes",
+ "libc",
+ "memchr",
+ "mio",
+ "num_cpus",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "tokio-macros",
+ "winapi",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54473be61f4ebe4efd09cec9bd5d16fa51d70ea0192213d754d2d500457db110"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2f3f698253f03119ac0102beaa64f67a67e08074d03a22d18784104543727f"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.toml
new file mode 100644
index 0000000..ed5b27d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_local/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "cargo_local"
+version = "0.1.0"
+authors = ["UebelAndre <github@uebelandre.com>"]
+edition = "2018"
+
+[dependencies]
+tokio = { version = "1.12.0", features = ["full"] }
+
+[dev-dependencies]
+tempfile = "3.2.0"
+tokio-test = "0.4.2"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_local/src/lib.rs b/third_party/rules_rust/examples/crate_universe/cargo_local/src/lib.rs
new file mode 100644
index 0000000..0e49d04
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_local/src/lib.rs
@@ -0,0 +1,44 @@
+use std::path::Path;
+
+use tokio::fs::File;
+use tokio::io::{AsyncBufReadExt, BufReader};
+
+pub async fn fill_buf_file(path: &Path) -> Vec<u8> {
+    let file = File::open(path).await.unwrap();
+    let mut file = BufReader::new(file);
+
+    let mut contents = Vec::new();
+
+    loop {
+        let consumed = {
+            let buffer = file.fill_buf().await.unwrap();
+            if buffer.is_empty() {
+                break;
+            }
+            contents.extend_from_slice(buffer);
+            buffer.len()
+        };
+
+        file.consume(consumed);
+    }
+
+    contents
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use tempfile::NamedTempFile;
+    use tokio_test::assert_ok;
+
+    #[tokio::test]
+    async fn test_fill_buf_file() {
+        let file = NamedTempFile::new().unwrap();
+        assert_ok!(std::fs::write(file.path(), b"hello"));
+
+        let contents = fill_buf_file(file.path()).await;
+
+        assert_eq!(contents, b"hello");
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_remote/.bazelrc b/third_party/rules_rust/examples/crate_universe/cargo_remote/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_remote/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.bazel
new file mode 100644
index 0000000..16e756d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.bazel
@@ -0,0 +1,14 @@
+load("@rules_rust//rust:defs.bzl", "rust_test")
+
+exports_files([
+    "BUILD.names.bazel",
+])
+
+rust_test(
+    name = "launch_test",
+    srcs = ["remote_crate_test.rs"],
+    data = ["@names//:names_bin"],
+    rustc_env = {
+        "EXECUTABLE": "$(rootpath @names//:names_bin)",
+    },
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.names.bazel b/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.names.bazel
new file mode 100644
index 0000000..83378f5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_remote/BUILD.names.bazel
@@ -0,0 +1,67 @@
+load("@crate_index_cargo_remote//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//cargo:defs.bzl", "cargo_build_script")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "Cargo.toml",
+    "Cargo.lock",
+])
+
+rust_binary(
+    name = "names_bin",
+    srcs = ["src/bin/names.rs"],
+    aliases = aliases(
+        normal = True,
+        proc_macro = True,
+    ),
+    crate_features = [
+        "application",
+        "clap",
+        "default",
+    ],
+    crate_root = "src/bin/names.rs",
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    version = "0.12.0",
+    deps = all_crate_deps(normal = True) + [
+        ":names",
+    ],
+)
+
+rust_library(
+    name = "names",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(
+        normal = True,
+        proc_macro = True,
+    ),
+    crate_features = [
+        "application",
+        "clap",
+        "default",
+    ],
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    version = "0.12.0",
+    deps = all_crate_deps(normal = True) + [
+        ":build-script-build",
+    ],
+)
+
+cargo_build_script(
+    name = "build-script-build",
+    srcs = ["build.rs"],
+    aliases = aliases(build = True),
+    crate_features = [
+        "application",
+        "clap",
+        "default",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["data/**"]),
+    edition = "2018",
+    version = "0.12.0",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_remote/remote_crate_test.rs b/third_party/rules_rust/examples/crate_universe/cargo_remote/remote_crate_test.rs
new file mode 100644
index 0000000..f25340a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_remote/remote_crate_test.rs
@@ -0,0 +1,18 @@
+//! A Test module confirming the functionality of `cargo->bazel` with remote crates.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+#[test]
+fn test_executable() {
+    let exe = PathBuf::from(env!("EXECUTABLE"));
+
+    let output = Command::new(exe)
+        .arg("--help")
+        .output()
+        .expect("Failed to run executable");
+
+    let text = String::from_utf8(output.stdout).unwrap();
+
+    assert!(text.contains("A random name generator with results like"));
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/.bazelrc b/third_party/rules_rust/examples/crate_universe/cargo_workspace/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_workspace/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/BUILD.bazel
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.Bazel.lock b/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.Bazel.lock
new file mode 100644
index 0000000..e71e918
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.Bazel.lock
@@ -0,0 +1,1462 @@
+{
+  "checksum": "0116dced5bffc719d9e8c3a9fc34b13d9f97c61125722f5bcb4079df12465f56",
+  "crates": {
+    "ansi_term 0.12.1": {
+      "name": "ansi_term",
+      "version": "0.12.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ansi_term/0.12.1/download",
+          "sha256": "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ansi_term",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ansi_term",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"windows\")": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.12.1"
+      },
+      "license": "MIT"
+    },
+    "atty 0.2.14": {
+      "name": "atty",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atty/0.2.14/download",
+          "sha256": "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atty",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atty",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"hermit\")": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "license": "MIT"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "clap 2.34.0": {
+      "name": "clap",
+      "version": "2.34.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap/2.34.0/download",
+          "sha256": "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "clap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "ansi_term",
+          "atty",
+          "color",
+          "default",
+          "strsim",
+          "suggestions",
+          "vec_map"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "strsim 0.8.0",
+              "target": "strsim"
+            },
+            {
+              "id": "textwrap 0.11.0",
+              "target": "textwrap"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            },
+            {
+              "id": "vec_map 0.8.2",
+              "target": "vec_map"
+            }
+          ],
+          "selects": {
+            "cfg(not(windows))": [
+              {
+                "id": "ansi_term 0.12.1",
+                "target": "ansi_term"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "2.34.0"
+      },
+      "license": "MIT"
+    },
+    "direct-cargo-bazel-deps 0.0.1": {
+      "name": "direct-cargo-bazel-deps",
+      "version": "0.0.1",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "direct_cargo_bazel_deps",
+            "crate_root": ".direct_cargo_bazel_deps.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "direct_cargo_bazel_deps",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.0.1"
+      },
+      "license": null
+    },
+    "ferris-says 0.2.1": {
+      "name": "ferris-says",
+      "version": "0.2.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ferris-says/0.2.1/download",
+          "sha256": "9515ec2dd9606ec230f6b2d1f25fd9e808a2f2af600143f7efe7e5865505b7aa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ferris_says",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ferris_says",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smallvec 0.4.5",
+              "target": "smallvec"
+            },
+            {
+              "id": "textwrap 0.13.4",
+              "target": "textwrap"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "getrandom 0.1.16": {
+      "name": "getrandom",
+      "version": "0.1.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/getrandom/0.1.16/download",
+          "sha256": "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "getrandom",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "getrandom",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "getrandom 0.1.16",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"wasi\")": [
+              {
+                "id": "wasi 0.9.0+wasi-snapshot-preview1",
+                "target": "wasi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.16"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num_printer 0.1.0": {
+      "name": "num_printer",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Binary": {
+            "crate_name": "number-printer",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": null,
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 2.34.0",
+              "target": "clap"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "ppv-lite86 0.2.16": {
+      "name": "ppv-lite86",
+      "version": "0.2.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ppv-lite86/0.2.16/download",
+          "sha256": "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ppv_lite86",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ppv_lite86",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "simd",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.2.16"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "printer 0.1.0": {
+      "name": "printer",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "printer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "printer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ferris-says 0.2.1",
+              "target": "ferris_says"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "rand 0.7.3": {
+      "name": "rand",
+      "version": "0.7.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand/0.7.3/download",
+          "sha256": "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "getrandom",
+          "getrandom_package",
+          "libc",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "getrandom 0.1.16",
+              "target": "getrandom",
+              "alias": "getrandom_package"
+            },
+            {
+              "id": "rand_core 0.5.1",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {
+            "cfg(not(target_os = \"emscripten\"))": [
+              {
+                "id": "rand_chacha 0.2.2",
+                "target": "rand_chacha"
+              }
+            ],
+            "cfg(target_os = \"emscripten\")": [
+              {
+                "id": "rand_hc 0.2.0",
+                "target": "rand_hc"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.7.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_chacha 0.2.2": {
+      "name": "rand_chacha",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_chacha/0.2.2/download",
+          "sha256": "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_chacha",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_chacha",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ppv-lite86 0.2.16",
+              "target": "ppv_lite86"
+            },
+            {
+              "id": "rand_core 0.5.1",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_core 0.5.1": {
+      "name": "rand_core",
+      "version": "0.5.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.5.1/download",
+          "sha256": "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "getrandom",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "getrandom 0.1.16",
+              "target": "getrandom"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.5.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_hc 0.2.0": {
+      "name": "rand_hc",
+      "version": "0.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_hc/0.2.0/download",
+          "sha256": "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_hc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_hc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_core 0.5.1",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rng 0.1.0": {
+      "name": "rng",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rng",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rng",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand 0.7.3",
+              "target": "rand"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "smallvec 0.4.5": {
+      "name": "smallvec",
+      "version": "0.4.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smallvec/0.4.5/download",
+          "sha256": "f90c5e5fe535e48807ab94fc611d323935f39d4660c52b26b96446a7b33aef10"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smallvec",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smallvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "0.4.5"
+      },
+      "license": "MPL-2.0"
+    },
+    "smawk 0.3.1": {
+      "name": "smawk",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smawk/0.3.1/download",
+          "sha256": "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smawk",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smawk",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "strsim 0.8.0": {
+      "name": "strsim",
+      "version": "0.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/strsim/0.8.0/download",
+          "sha256": "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "strsim",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "strsim",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.8.0"
+      },
+      "license": "MIT"
+    },
+    "textwrap 0.11.0": {
+      "name": "textwrap",
+      "version": "0.11.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.11.0/download",
+          "sha256": "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.11.0"
+      },
+      "license": "MIT"
+    },
+    "textwrap 0.13.4": {
+      "name": "textwrap",
+      "version": "0.13.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.13.4/download",
+          "sha256": "cd05616119e612a8041ef58f2b578906cc2531a6069047ae092cfb86a325d835"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "smawk",
+          "unicode-width"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smawk 0.3.1",
+              "target": "smawk"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.13.4"
+      },
+      "license": "MIT"
+    },
+    "unicode-width 0.1.9": {
+      "name": "unicode-width",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-width/0.1.9/download",
+          "sha256": "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_width",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_width",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "vec_map 0.8.2": {
+      "name": "vec_map",
+      "version": "0.8.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/vec_map/0.8.2/download",
+          "sha256": "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "vec_map",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "vec_map",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.8.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasi 0.9.0+wasi-snapshot-preview1": {
+      "name": "wasi",
+      "version": "0.9.0+wasi-snapshot-preview1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasi/0.9.0+wasi-snapshot-preview1/download",
+          "sha256": "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.9.0+wasi-snapshot-preview1"
+      },
+      "license": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "consoleapi",
+          "errhandlingapi",
+          "fileapi",
+          "handleapi",
+          "minwinbase",
+          "minwindef",
+          "processenv",
+          "winbase"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    }
+  },
+  "binary_crates": [],
+  "workspace_members": {
+    "direct-cargo-bazel-deps 0.0.1": "cargo_workspace",
+    "num_printer 0.1.0": "cargo_workspace/num_printer",
+    "printer 0.1.0": "cargo_workspace/printer",
+    "rng 0.1.0": "cargo_workspace/rng"
+  },
+  "conditions": {
+    "cfg(not(target_os = \"emscripten\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-pc-windows-msvc",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(windows))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(target_os = \"emscripten\")": [],
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"wasi\")": [
+      "wasm32-wasi"
+    ],
+    "cfg(target_os = \"windows\")": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": []
+  }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.toml
new file mode 100644
index 0000000..4bf10a5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/Cargo.toml
@@ -0,0 +1,6 @@
+[workspace]
+members = [
+    "num_printer",
+    "printer",
+    "rng",
+]
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/BUILD.bazel
new file mode 100644
index 0000000..eb94da1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/BUILD.bazel
@@ -0,0 +1,13 @@
+load("@crate_index_cargo_workspace//:defs.bzl", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "number_printer",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+    deps = [
+        "//cargo_workspace/printer",
+    ] + all_crate_deps(),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/Cargo.toml
new file mode 100644
index 0000000..b3711a0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "num_printer"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "number-printer"
+path = "src/main.rs"
+
+[dependencies]
+clap = "2.33.3"
+printer = { path = "../printer" }
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/src/main.rs b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/src/main.rs
new file mode 100644
index 0000000..871c7b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/num_printer/src/main.rs
@@ -0,0 +1,24 @@
+use clap::{App, Arg};
+
+fn main() {
+    let matches = App::new("Number Printer")
+        .about("Print some numbers")
+        .arg(Arg::with_name("rng").help("Print a random number"))
+        .arg(
+            Arg::with_name("num")
+                .help("Print this number")
+                .takes_value(true),
+        )
+        .get_matches();
+
+    let num = match matches.value_of("num") {
+        Some(value) => value.parse::<i32>().unwrap(),
+        None => 1337,
+    };
+
+    if matches.is_present("rng") {
+        println!("{}", printer::say_random_number());
+    } else {
+        println!("{}", printer::say_number(num));
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/BUILD.bazel
new file mode 100644
index 0000000..7d14cae
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@crate_index_cargo_workspace//:defs.bzl", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "printer",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    deps = [
+        "//cargo_workspace/rng",
+    ] + all_crate_deps(),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":printer",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/Cargo.toml
new file mode 100644
index 0000000..9e3537a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "printer"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+rng = { path = "../rng" }
+ferris-says = "0.2.0"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/src/lib.rs b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/src/lib.rs
new file mode 100644
index 0000000..8828dc3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/printer/src/lib.rs
@@ -0,0 +1,38 @@
+use std::io::BufWriter;
+
+/// Have ferris say a number
+pub fn say_number(num: i32) -> String {
+    let number = format!("{}", num);
+    let buf = Vec::new();
+    let mut writer = BufWriter::new(buf);
+    ferris_says::say(number.as_bytes(), number.len(), &mut writer).unwrap();
+    String::from_utf8(writer.into_inner().unwrap()).unwrap()
+}
+
+/// Have ferris say a random number
+pub fn say_random_number() -> String {
+    say_number(rng::random_number())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_say_number() {
+        let said = say_number(3);
+        assert!(said.contains(r#"    _~^~^~_"#));
+        assert!(said.contains(r#"\) /  o o  \ (/"#));
+        assert!(said.contains(r#"  '_   -   _'"#));
+        assert!(said.contains(r#"  / '-----' \"#));
+    }
+
+    #[test]
+    fn test_say_random_number() {
+        let said = say_random_number();
+        assert!(said.contains(r#"    _~^~^~_"#));
+        assert!(said.contains(r#"\) /  o o  \ (/"#));
+        assert!(said.contains(r#"  '_   -   _'"#));
+        assert!(said.contains(r#"  / '-----' \"#));
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/BUILD.bazel
new file mode 100644
index 0000000..f05506c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/BUILD.bazel
@@ -0,0 +1,13 @@
+load("@crate_index_cargo_workspace//:defs.bzl", "crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "rng",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    deps = crate_deps([
+        "rand",
+    ]),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/Cargo.toml b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/Cargo.toml
new file mode 100644
index 0000000..a2a098c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "rng"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+rand = "0.7.3"
diff --git a/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/src/lib.rs b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/src/lib.rs
new file mode 100644
index 0000000..3d9a045
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/cargo_workspace/rng/src/lib.rs
@@ -0,0 +1,7 @@
+use rand::{thread_rng, Rng};
+
+/// Generate a random number
+pub fn random_number() -> i32 {
+    let mut rng = thread_rng();
+    rng.gen()
+}
diff --git a/third_party/rules_rust/examples/crate_universe/extra_workspace_members/.bazelrc b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/extra_workspace_members/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/BUILD.bazel
new file mode 100644
index 0000000..199257f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/BUILD.bazel
@@ -0,0 +1,22 @@
+load("@crate_index_extra_members//:defs.bzl", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
+
+rust_binary(
+    name = "extra_workspace_member",
+    srcs = ["src/main.rs"],
+    data = ["@crate_index_extra_members//:texture-synthesis-cli__texture-synthesis"],
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    rustc_env = {
+        "TEXTURE_SYNTHESIS_CLI": "$(rootpath @crate_index_extra_members//:texture-synthesis-cli__texture-synthesis)",
+    },
+    deps = all_crate_deps(),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":extra_workspace_member",
+    data = ["@crate_index_extra_members//:texture-synthesis-cli__texture-synthesis"],
+    rustc_env = {
+        "TEXTURE_SYNTHESIS_CLI": "$(rootpath @crate_index_extra_members//:texture-synthesis-cli__texture-synthesis)",
+    },
+)
diff --git a/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.Bazel.lock b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.Bazel.lock
new file mode 100644
index 0000000..c9d296d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.Bazel.lock
@@ -0,0 +1,3273 @@
+{
+  "checksum": "e3970ece78ced37e01b3e8d70f9b1350e9d902a2be78f8c08789b05242583bef",
+  "crates": {
+    "adler32 1.2.0": {
+      "name": "adler32",
+      "version": "1.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/adler32/1.2.0/download",
+          "sha256": "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "adler32",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "adler32",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.2.0"
+      },
+      "license": "Zlib"
+    },
+    "ansi_term 0.12.1": {
+      "name": "ansi_term",
+      "version": "0.12.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ansi_term/0.12.1/download",
+          "sha256": "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ansi_term",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ansi_term",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"windows\")": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.12.1"
+      },
+      "license": "MIT"
+    },
+    "atty 0.2.14": {
+      "name": "atty",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atty/0.2.14/download",
+          "sha256": "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atty",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atty",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"hermit\")": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "license": "MIT"
+    },
+    "autocfg 1.1.0": {
+      "name": "autocfg",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/autocfg/1.1.0/download",
+          "sha256": "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "autocfg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "autocfg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "bytemuck 1.8.0": {
+      "name": "bytemuck",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bytemuck/1.8.0/download",
+          "sha256": "0e851ca7c24871e7336801608a4797d7376545b6928a10d32d75685687141ead"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bytemuck",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bytemuck",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "license": "Zlib OR Apache-2.0 OR MIT"
+    },
+    "byteorder 1.4.3": {
+      "name": "byteorder",
+      "version": "1.4.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/byteorder/1.4.3/download",
+          "sha256": "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "byteorder",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "byteorder",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.4.3"
+      },
+      "license": "Unlicense OR MIT"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "clap 2.34.0": {
+      "name": "clap",
+      "version": "2.34.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/clap/2.34.0/download",
+          "sha256": "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "clap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "clap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "ansi_term",
+          "atty",
+          "color",
+          "default",
+          "strsim",
+          "suggestions",
+          "vec_map"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "strsim 0.8.0",
+              "target": "strsim"
+            },
+            {
+              "id": "textwrap 0.11.0",
+              "target": "textwrap"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            },
+            {
+              "id": "vec_map 0.8.2",
+              "target": "vec_map"
+            }
+          ],
+          "selects": {
+            "cfg(not(windows))": [
+              {
+                "id": "ansi_term 0.12.1",
+                "target": "ansi_term"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "2.34.0"
+      },
+      "license": "MIT"
+    },
+    "color_quant 1.1.0": {
+      "name": "color_quant",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/color_quant/1.1.0/download",
+          "sha256": "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "color_quant",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "color_quant",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "MIT"
+    },
+    "console 0.15.0": {
+      "name": "console",
+      "version": "0.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/console/0.15.0/download",
+          "sha256": "a28b32d32ca44b70c3e4acd7db1babf555fa026e385fb95f18028f88848b3c31"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "console",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "console",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "ansi-parsing",
+          "default",
+          "regex",
+          "unicode-width"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "terminal_size 0.1.17",
+              "target": "terminal_size"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "encode_unicode 0.3.6",
+                "target": "encode_unicode"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.15.0"
+      },
+      "license": "MIT"
+    },
+    "crc32fast 1.3.2": {
+      "name": "crc32fast",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crc32fast/1.3.2/download",
+          "sha256": "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crc32fast",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crc32fast",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "crc32fast 1.3.2",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.3.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "crossbeam-utils 0.8.7": {
+      "name": "crossbeam-utils",
+      "version": "0.8.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crossbeam-utils/0.8.7/download",
+          "sha256": "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crossbeam_utils",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crossbeam_utils",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lazy_static",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "deflate 0.8.6": {
+      "name": "deflate",
+      "version": "0.8.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/deflate/0.8.6/download",
+          "sha256": "73770f8e1fe7d64df17ca66ad28994a0a623ea497fa69486e14984e715c5d174"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "deflate",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "deflate",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "adler32 1.2.0",
+              "target": "adler32"
+            },
+            {
+              "id": "byteorder 1.4.3",
+              "target": "byteorder"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.6"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "encode_unicode 0.3.6": {
+      "name": "encode_unicode",
+      "version": "0.3.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/encode_unicode/0.3.6/download",
+          "sha256": "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "encode_unicode",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "encode_unicode",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "0.3.6"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "extra_workspace_members 0.1.0": {
+      "name": "extra_workspace_members",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Binary": {
+            "crate_name": "extra_workspace_members",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": null,
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ferris-says 0.2.1",
+              "target": "ferris_says"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "ferris-says 0.2.1": {
+      "name": "ferris-says",
+      "version": "0.2.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ferris-says/0.2.1/download",
+          "sha256": "9515ec2dd9606ec230f6b2d1f25fd9e808a2f2af600143f7efe7e5865505b7aa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ferris_says",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ferris_says",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smallvec 0.4.5",
+              "target": "smallvec"
+            },
+            {
+              "id": "textwrap 0.13.4",
+              "target": "textwrap"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "heck 0.3.3": {
+      "name": "heck",
+      "version": "0.3.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/heck/0.3.3/download",
+          "sha256": "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "heck",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "heck",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unicode-segmentation 1.9.0",
+              "target": "unicode_segmentation"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "image 0.23.12": {
+      "name": "image",
+      "version": "0.23.12",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/image/0.23.12/download",
+          "sha256": "7ce04077ead78e39ae8610ad26216aed811996b043d47beed5090db674f9e9b5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "image",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "image",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "bmp",
+          "jpeg",
+          "png"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytemuck 1.8.0",
+              "target": "bytemuck"
+            },
+            {
+              "id": "byteorder 1.4.3",
+              "target": "byteorder"
+            },
+            {
+              "id": "color_quant 1.1.0",
+              "target": "color_quant"
+            },
+            {
+              "id": "jpeg-decoder 0.1.22",
+              "target": "jpeg_decoder",
+              "alias": "jpeg"
+            },
+            {
+              "id": "num-iter 0.1.42",
+              "target": "num_iter"
+            },
+            {
+              "id": "num-rational 0.3.2",
+              "target": "num_rational"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            },
+            {
+              "id": "png 0.16.8",
+              "target": "png"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.23.12"
+      },
+      "license": "MIT"
+    },
+    "indicatif 0.15.0": {
+      "name": "indicatif",
+      "version": "0.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/indicatif/0.15.0/download",
+          "sha256": "7baab56125e25686df467fe470785512329883aab42696d661247aca2a2896e4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "indicatif",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "indicatif",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "console 0.15.0",
+              "target": "console"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "number_prefix 0.3.0",
+              "target": "number_prefix"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.15.0"
+      },
+      "license": "MIT"
+    },
+    "jpeg-decoder 0.1.22": {
+      "name": "jpeg-decoder",
+      "version": "0.1.22",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/jpeg-decoder/0.1.22/download",
+          "sha256": "229d53d58899083193af11e15917b5640cd40b29ff475a1fe4ef725deb02d0f2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "jpeg_decoder",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "jpeg_decoder",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.22"
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "lazy_static 1.4.0": {
+      "name": "lazy_static",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+          "sha256": "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lazy_static",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lazy_static",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "miniz_oxide 0.3.7": {
+      "name": "miniz_oxide",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/miniz_oxide/0.3.7/download",
+          "sha256": "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "miniz_oxide",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "miniz_oxide",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "adler32 1.2.0",
+              "target": "adler32"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "license": "MIT"
+    },
+    "num-integer 0.1.44": {
+      "name": "num-integer",
+      "version": "0.1.44",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-integer/0.1.44/download",
+          "sha256": "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_integer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_integer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "i128",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "build_script_build"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.44"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num-iter 0.1.42": {
+      "name": "num-iter",
+      "version": "0.1.42",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-iter/0.1.42/download",
+          "sha256": "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_iter",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_iter",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-iter 0.1.42",
+              "target": "build_script_build"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.42"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num-rational 0.3.2": {
+      "name": "num-rational",
+      "version": "0.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-rational/0.3.2/download",
+          "sha256": "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_rational",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_rational",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-integer 0.1.44",
+              "target": "num_integer"
+            },
+            {
+              "id": "num-rational 0.3.2",
+              "target": "build_script_build"
+            },
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num-traits 0.2.14": {
+      "name": "num-traits",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num-traits/0.2.14/download",
+          "sha256": "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_traits",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_traits",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "i128",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-traits 0.2.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "num_cpus 1.13.1": {
+      "name": "num_cpus",
+      "version": "1.13.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num_cpus/1.13.1/download",
+          "sha256": "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_cpus",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_cpus",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(not(windows))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "1.13.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "number_prefix 0.3.0": {
+      "name": "number_prefix",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/number_prefix/0.3.0/download",
+          "sha256": "17b02fc0ff9a9e4b35b3342880f48e896ebf69f2967921fe8646bf5b7125956a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "number_prefix",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "number_prefix",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "once_cell 1.10.0": {
+      "name": "once_cell",
+      "version": "1.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/once_cell/1.10.0/download",
+          "sha256": "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "once_cell",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "once_cell",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "race",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.10.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "pdqselect 0.1.1": {
+      "name": "pdqselect",
+      "version": "0.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pdqselect/0.1.1/download",
+          "sha256": "7778906d9321dd56cde1d1ffa69a73e59dcf5fda6d366f62727adf2bd4193aee"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pdqselect",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pdqselect",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2021",
+        "version": "0.1.1"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "png 0.16.8": {
+      "name": "png",
+      "version": "0.16.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/png/0.16.8/download",
+          "sha256": "3c3287920cb847dee3de33d301c463fba14dda99db24214ddf93f83d3021f4c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "png",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "png",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "deflate",
+          "png-encoding"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "crc32fast 1.3.2",
+              "target": "crc32fast"
+            },
+            {
+              "id": "deflate 0.8.6",
+              "target": "deflate"
+            },
+            {
+              "id": "miniz_oxide 0.3.7",
+              "target": "miniz_oxide"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.16.8"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro-error 1.0.4": {
+      "name": "proc-macro-error",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error/1.0.4/download",
+          "sha256": "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro_error",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "syn",
+          "syn-error"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "proc_macro_error_attr"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro-error-attr 1.0.4": {
+      "name": "proc-macro-error-attr",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro-error-attr/1.0.4/download",
+          "sha256": "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "proc_macro_error_attr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro_error_attr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro-error-attr 1.0.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro2 1.0.36": {
+      "name": "proc-macro2",
+      "version": "1.0.36",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro2/1.0.36/download",
+          "sha256": "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.36"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "quote 1.0.15": {
+      "name": "quote",
+      "version": "1.0.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/quote/1.0.15/download",
+          "sha256": "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "quote",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "quote",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.15"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand 0.8.5": {
+      "name": "rand",
+      "version": "0.8.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand/0.8.5/download",
+          "sha256": "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_core 0.6.3": {
+      "name": "rand_core",
+      "version": "0.6.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_core/0.6.3/download",
+          "sha256": "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.6.3"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "rand_pcg 0.3.1": {
+      "name": "rand_pcg",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rand_pcg/0.3.1/download",
+          "sha256": "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rand_pcg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rand_pcg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rand_core 0.6.3",
+              "target": "rand_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex 1.5.4": {
+      "name": "regex",
+      "version": "1.5.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex/1.5.4/download",
+          "sha256": "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "regex-syntax 0.6.25",
+              "target": "regex_syntax"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex-syntax 0.6.25": {
+      "name": "regex-syntax",
+      "version": "0.6.25",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+          "sha256": "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex_syntax",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex_syntax",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.6.25"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rstar 0.7.1": {
+      "name": "rstar",
+      "version": "0.7.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rstar/0.7.1/download",
+          "sha256": "0650eaaa56cbd1726fd671150fce8ac6ed9d9a25d1624430d7ee9d196052f6b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "rstar",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rstar",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "num-traits 0.2.14",
+              "target": "num_traits"
+            },
+            {
+              "id": "pdqselect 0.1.1",
+              "target": "pdqselect"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "smallvec 0.4.5": {
+      "name": "smallvec",
+      "version": "0.4.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smallvec/0.4.5/download",
+          "sha256": "f90c5e5fe535e48807ab94fc611d323935f39d4660c52b26b96446a7b33aef10"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smallvec",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smallvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "0.4.5"
+      },
+      "license": "MPL-2.0"
+    },
+    "smawk 0.3.1": {
+      "name": "smawk",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smawk/0.3.1/download",
+          "sha256": "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smawk",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smawk",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "strsim 0.8.0": {
+      "name": "strsim",
+      "version": "0.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/strsim/0.8.0/download",
+          "sha256": "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "strsim",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "strsim",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.8.0"
+      },
+      "license": "MIT"
+    },
+    "structopt 0.3.26": {
+      "name": "structopt",
+      "version": "0.3.26",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/structopt/0.3.26/download",
+          "sha256": "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "structopt",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "structopt",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "clap 2.34.0",
+              "target": "clap"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "structopt-derive 0.4.18",
+              "target": "structopt_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.3.26"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "structopt-derive 0.4.18": {
+      "name": "structopt-derive",
+      "version": "0.4.18",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/structopt-derive/0.4.18/download",
+          "sha256": "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "structopt_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "structopt_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "heck 0.3.3",
+              "target": "heck"
+            },
+            {
+              "id": "proc-macro-error 1.0.4",
+              "target": "proc_macro_error"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.18"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "syn 1.0.86": {
+      "name": "syn",
+      "version": "1.0.86",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/syn/1.0.86/download",
+          "sha256": "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clone-impls",
+          "default",
+          "derive",
+          "full",
+          "parsing",
+          "printing",
+          "proc-macro",
+          "quote"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.86"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "terminal_size 0.1.17": {
+      "name": "terminal_size",
+      "version": "0.1.17",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/terminal_size/0.1.17/download",
+          "sha256": "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "terminal_size",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "terminal_size",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(not(windows))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.17"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "texture-synthesis 0.8.2": {
+      "name": "texture-synthesis",
+      "version": "0.8.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/texture-synthesis/0.8.2/download",
+          "sha256": "62ff62ae485126fec4f3685ced13a1700afb6f6ea12a1a0dec410ebc5dc9378b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "texture_synthesis",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "texture_synthesis",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "image 0.23.12",
+              "target": "image"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "rand 0.8.5",
+              "target": "rand"
+            },
+            {
+              "id": "rand_pcg 0.3.1",
+              "target": "rand_pcg"
+            },
+            {
+              "id": "rstar 0.7.1",
+              "target": "rstar"
+            }
+          ],
+          "selects": {
+            "cfg(not(target_arch = \"wasm32\"))": [
+              {
+                "id": "crossbeam-utils 0.8.7",
+                "target": "crossbeam_utils"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "texture-synthesis-cli 0.8.2": {
+      "name": "texture-synthesis-cli",
+      "version": "0.8.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/texture-synthesis-cli/0.8.2/download",
+          "sha256": "a7dbdf13f5e6f214750fce1073279b71ce3076157a8d337c9b0f0e14334e2aec"
+        }
+      },
+      "targets": [
+        {
+          "Binary": {
+            "crate_name": "texture-synthesis",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": null,
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "structopt 0.3.26",
+              "target": "structopt"
+            },
+            {
+              "id": "texture-synthesis 0.8.2",
+              "target": "texture_synthesis"
+            }
+          ],
+          "selects": {
+            "cfg(not(target_arch = \"wasm32\"))": [
+              {
+                "id": "atty 0.2.14",
+                "target": "atty"
+              },
+              {
+                "id": "indicatif 0.15.0",
+                "target": "indicatif"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "textwrap 0.11.0": {
+      "name": "textwrap",
+      "version": "0.11.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.11.0/download",
+          "sha256": "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.11.0"
+      },
+      "license": "MIT"
+    },
+    "textwrap 0.13.4": {
+      "name": "textwrap",
+      "version": "0.13.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/textwrap/0.13.4/download",
+          "sha256": "cd05616119e612a8041ef58f2b578906cc2531a6069047ae092cfb86a325d835"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "textwrap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "textwrap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "smawk",
+          "unicode-width"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "smawk 0.3.1",
+              "target": "smawk"
+            },
+            {
+              "id": "unicode-width 0.1.9",
+              "target": "unicode_width"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.13.4"
+      },
+      "license": "MIT"
+    },
+    "unicode-segmentation 1.9.0": {
+      "name": "unicode-segmentation",
+      "version": "1.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-segmentation/1.9.0/download",
+          "sha256": "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_segmentation",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_segmentation",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.9.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-width 0.1.9": {
+      "name": "unicode-width",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-width/0.1.9/download",
+          "sha256": "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_width",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_width",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-xid 0.2.2": {
+      "name": "unicode-xid",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+          "sha256": "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_xid",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_xid",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "vec_map 0.8.2": {
+      "name": "vec_map",
+      "version": "0.8.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/vec_map/0.8.2/download",
+          "sha256": "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "vec_map",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "vec_map",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.8.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "version_check 0.9.4": {
+      "name": "version_check",
+      "version": "0.9.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/version_check/0.9.4/download",
+          "sha256": "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "version_check",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "version_check",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.9.4"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "consoleapi",
+          "errhandlingapi",
+          "fileapi",
+          "handleapi",
+          "minwinbase",
+          "minwindef",
+          "processenv",
+          "winbase",
+          "wincon",
+          "winnt",
+          "winuser"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    }
+  },
+  "binary_crates": [
+    "texture-synthesis-cli 0.8.2"
+  ],
+  "workspace_members": {
+    "extra_workspace_members 0.1.0": "extra_workspace_members"
+  },
+  "conditions": {
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(not(target_arch = \"wasm32\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-pc-windows-msvc",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(windows))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"windows\")": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": []
+  }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.toml b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.toml
new file mode 100644
index 0000000..2577506
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "extra_workspace_members"
+version = "0.1.0"
+authors = ["UebelAndre <github@uebelandre.com>"]
+
+[[bin]]
+name = "extra_workspace_members"
+path = "src/main.rs"
+
+[dependencies]
+ferris-says = "0.2.1"
diff --git a/third_party/rules_rust/examples/crate_universe/extra_workspace_members/src/main.rs b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/src/main.rs
new file mode 100644
index 0000000..0f2fffe
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/extra_workspace_members/src/main.rs
@@ -0,0 +1,39 @@
+use std::io::{stdout, BufWriter};
+use std::path::Path;
+use std::process::Command;
+
+fn execute_texture_synthesis() -> Vec<u8> {
+    let texture_synthesis_path = Path::new(env!("TEXTURE_SYNTHESIS_CLI"));
+
+    let output = Command::new(texture_synthesis_path)
+        .arg("--help")
+        .output()
+        .unwrap();
+
+    if !output.status.success() {
+        panic!("Execution of texter-synthesis-cli failed")
+    }
+
+    output.stdout
+}
+
+fn main() {
+    // Run the command
+    let output = execute_texture_synthesis();
+
+    // Print the results
+    let mut writer = BufWriter::new(stdout());
+    ferris_says::say(&output, 120, &mut writer).unwrap();
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_output() {
+        let stdout = execute_texture_synthesis();
+        let text = String::from_utf8(stdout).unwrap();
+        assert!(text.contains("Synthesizes images based on example images"));
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/.bazelrc b/third_party/rules_rust/examples/crate_universe/multi_package/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.bazel
new file mode 100644
index 0000000..77a676d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.bazel
@@ -0,0 +1,4 @@
+exports_files(
+    glob(["*.bazel"]),
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.curl.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.curl.bazel
new file mode 100644
index 0000000..0337de2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.curl.bazel
@@ -0,0 +1,56 @@
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake")
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+_CACHE_ENTRIES = {
+    "BUILD_CURL_EXE": "off",
+    "BUILD_SHARED_LIBS": "off",
+    "CMAKE_BUILD_TYPE": "RELEASE",
+    "CMAKE_PREFIX_PATH": "$$EXT_BUILD_DEPS$$/openssl",
+    "CMAKE_USE_OPENSSL": "on",
+    # TODO: ldap should likely be enabled
+    "CURL_DISABLE_LDAP": "on",
+    "OPENSSL_ROOT_DIR": "$$EXT_BUILD_DEPS$$/openssl",
+}
+
+_MACOS_CACHE_ENTRIES = dict(_CACHE_ENTRIES.items() + {
+    "CMAKE_AR": "",
+    "CMAKE_C_ARCHIVE_CREATE": "",
+}.items())
+
+_LINUX_CACHE_ENTRIES = dict(_CACHE_ENTRIES.items() + {
+    "CMAKE_C_FLAGS": "-fPIC",
+}.items())
+
+cmake(
+    name = "curl",
+    cache_entries = select({
+        "@platforms//os:linux": _LINUX_CACHE_ENTRIES,
+        "@platforms//os:macos": _MACOS_CACHE_ENTRIES,
+        "//conditions:default": _CACHE_ENTRIES,
+    }),
+    generate_args = select({
+        "@platforms//os:windows": ["-GNinja"],
+        "//conditions:default": [],
+    }),
+    generate_crosstool_file = False,
+    lib_source = ":all_srcs",
+    linkopts = select({
+        "@platforms//os:linux": [
+            "-lpthread",
+        ],
+        "//conditions:default": [],
+    }),
+    out_static_libs = select({
+        "@platforms//os:windows": ["libcurl.lib"],
+        "//conditions:default": ["libcurl.a"],
+    }),
+    visibility = ["//visibility:public"],
+    deps = [
+        "@openssl",
+        "@zlib",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.libssh2.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.libssh2.bazel
new file mode 100644
index 0000000..a1baada
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.libssh2.bazel
@@ -0,0 +1,34 @@
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake")
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+_CACHE_ENTRIES = {
+    "BUILD_EXAMPLES": "off",
+    "BUILD_SHARED_LIBS": "off",
+    "BUILD_TESTING": "off",
+    "CMAKE_FIND_DEBUG_MODE": "on",
+    "CMAKE_PREFIX_PATH": "${CMAKE_PREFIX_PATH:-};$EXT_BUILD_DEPS/openssl",
+}
+
+_LINUX_CACHE_ENTRIES = dict(_CACHE_ENTRIES.items() + {
+    "CMAKE_C_FLAGS": "${CMAKE_C_FLAGS:-} -fPIC",
+}.items())
+
+cmake(
+    name = "libssh2",
+    cache_entries = select({
+        "@platforms//os:linux": _LINUX_CACHE_ENTRIES,
+        "//conditions:default": _CACHE_ENTRIES,
+    }),
+    lib_source = ":all_srcs",
+    out_static_libs = select({
+        # TODO: I'm guessing at this name. Needs to be checked on windows.
+        "@platforms//os:windows": ["libssh2.lib"],
+        "//conditions:default": ["libssh2.a"],
+    }),
+    visibility = ["//visibility:public"],
+    deps = ["@openssl"],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.nasm.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.nasm.bazel
new file mode 100644
index 0000000..cf9586b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.nasm.bazel
@@ -0,0 +1,14 @@
+load("@bazel_skylib//rules:select_file.bzl", "select_file")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+select_file(
+    name = "nasm",
+    srcs = ":all_srcs",
+    subpath = "nasm.exe",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.openssl.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.openssl.bazel
new file mode 100644
index 0000000..19d0a8c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.openssl.bazel
@@ -0,0 +1,107 @@
+"""An openssl build file based on a snippet found in the github issue:
+https://github.com/bazelbuild/rules_foreign_cc/issues/337
+"""
+
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "configure_make", "configure_make_variant")
+
+# Read https://wiki.openssl.org/index.php/Compilation_and_Installation
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+CONFIGURE_OPTIONS = [
+    "no-comp",
+    "no-idea",
+    "no-weak-ssl-ciphers",
+    "no-shared",
+]
+
+LIB_NAME = "openssl"
+
+MAKE_TARGETS = [
+    "build_libs",
+    "install_dev",
+]
+
+config_setting(
+    name = "msvc_compiler",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "msvc-cl",
+    },
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "openssl",
+    actual = select({
+        ":msvc_compiler": "openssl_msvc",
+        "//conditions:default": "openssl_default",
+    }),
+    visibility = ["//visibility:public"],
+)
+
+configure_make_variant(
+    name = "openssl_msvc",
+    build_data = [
+        "@nasm//:nasm",
+        "@perl//:perl",
+    ],
+    configure_command = "Configure",
+    configure_in_place = True,
+    configure_options = CONFIGURE_OPTIONS + [
+        "VC-WIN64A",
+        # Unset Microsoft Assembler (MASM) flags set by built-in MSVC toolchain,
+        # as NASM is unsed to build OpenSSL rather than MASM
+        "ASFLAGS=\" \"",
+    ],
+    configure_prefix = "$PERL",
+    env = {
+        # The Zi flag must be set otherwise OpenSSL fails to build due to missing .pdb files
+        "CFLAGS": "-Zi",
+        "PATH": "$$(dirname $(execpath @nasm//:nasm)):$$PATH",
+        "PERL": "$(execpath @perl//:perl)",
+    },
+    lib_name = LIB_NAME,
+    lib_source = ":all_srcs",
+    out_static_libs = [
+        "libssl.lib",
+        "libcrypto.lib",
+    ],
+    targets = MAKE_TARGETS,
+    toolchain = "@rules_foreign_cc//toolchains:preinstalled_nmake_toolchain",
+)
+
+configure_make(
+    name = "openssl_default",
+    configure_command = "config",
+    configure_in_place = True,
+    configure_options = CONFIGURE_OPTIONS,
+    env = select({
+        "@platforms//os:macos": {
+            "AR": "",
+            "PERL": "$$EXT_BUILD_ROOT$$/$(PERL)",
+        },
+        "//conditions:default": {
+            "PERL": "$$EXT_BUILD_ROOT$$/$(PERL)",
+        },
+    }),
+    lib_name = LIB_NAME,
+    lib_source = ":all_srcs",
+    # Note that for Linux builds, libssl must come before libcrypto on the linker command-line.
+    # As such, libssl must be listed before libcrypto
+    out_static_libs = [
+        "libssl.a",
+        "libcrypto.a",
+    ],
+    targets = MAKE_TARGETS,
+    toolchains = ["@rules_perl//:current_toolchain"],
+)
+
+filegroup(
+    name = "gen_dir",
+    srcs = [":openssl"],
+    output_group = "gen_dir",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.perl.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.perl.bazel
new file mode 100644
index 0000000..8d7bbe2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/BUILD.perl.bazel
@@ -0,0 +1,14 @@
+load("@bazel_skylib//rules:select_file.bzl", "select_file")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+select_file(
+    name = "perl",
+    srcs = ":all_srcs",
+    subpath = "perl/bin/perl.exe",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/third_party_deps.bzl b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/third_party_deps.bzl
new file mode 100644
index 0000000..fbbf70d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/3rdparty/third_party_deps.bzl
@@ -0,0 +1,85 @@
+"""A helper module for loading 3rd party dependencies
+The sources here originate from: https://github.com/bazelbuild/rules_foreign_cc/tree/0.6.0/examples/third_party/openssl
+"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+def third_party_deps(prefix = ""):
+    """Definitions for 3rd party dependencies
+
+    Args:
+        prefix (str, optional): An optional prefix for all dependencies
+    """
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "openssl").lstrip("_"),
+        build_file = Label("//multi_package/3rdparty:BUILD.openssl.bazel"),
+        sha256 = "892a0875b9872acd04a9fde79b1f943075d5ea162415de3047c327df33fbaee5",
+        strip_prefix = "openssl-1.1.1k",
+        urls = [
+            "https://mirror.bazel.build/www.openssl.org/source/openssl-1.1.1k.tar.gz",
+            "https://www.openssl.org/source/openssl-1.1.1k.tar.gz",
+            "https://github.com/openssl/openssl/archive/OpenSSL_1_1_1k.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "nasm").lstrip("_"),
+        build_file = Label("//multi_package/3rdparty:BUILD.nasm.bazel"),
+        sha256 = "f5c93c146f52b4f1664fa3ce6579f961a910e869ab0dae431bd871bdd2584ef2",
+        strip_prefix = "nasm-2.15.05",
+        urls = [
+            "https://mirror.bazel.build/www.nasm.us/pub/nasm/releasebuilds/2.15.05/win64/nasm-2.15.05-win64.zip",
+            "https://www.nasm.us/pub/nasm/releasebuilds/2.15.05/win64/nasm-2.15.05-win64.zip",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "perl").lstrip("_"),
+        build_file = Label("//multi_package/3rdparty:BUILD.perl.bazel"),
+        sha256 = "aeb973da474f14210d3e1a1f942dcf779e2ae7e71e4c535e6c53ebabe632cc98",
+        urls = [
+            "https://mirror.bazel.build/strawberryperl.com/download/5.32.1.1/strawberry-perl-5.32.1.1-64bit.zip",
+            "https://strawberryperl.com/download/5.32.1.1/strawberry-perl-5.32.1.1-64bit.zip",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "curl").lstrip("_"),
+        build_file = Label("//multi_package/3rdparty:BUILD.curl.bazel"),
+        sha256 = "e56b3921eeb7a2951959c02db0912b5fcd5fdba5aca071da819e1accf338bbd7",
+        strip_prefix = "curl-7.74.0",
+        type = "tar.gz",
+        urls = [
+            "https://curl.se/download/curl-7.74.0.tar.gz",
+            "https://github.com/curl/curl/releases/download/curl-7_74_0/curl-7.74.0.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "zlib").lstrip("_"),
+        build_file = Label("//crate_universe/3rdparty:BUILD.zlib.bazel"),
+        sha256 = "c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1",
+        strip_prefix = "zlib-1.2.11",
+        urls = [
+            "https://zlib.net/zlib-1.2.11.tar.gz",
+            "https://storage.googleapis.com/mirror.tensorflow.org/zlib.net/zlib-1.2.11.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = (prefix + "__" + "libssh2").lstrip("_"),
+        build_file = Label("//multi_package/3rdparty:BUILD.libssh2.bazel"),
+        sha256 = "d5fb8bd563305fd1074dda90bd053fb2d29fc4bce048d182f96eaa466dfadafd",
+        strip_prefix = "libssh2-1.9.0",
+        type = "tar.gz",
+        urls = [
+            "https://github.com/libssh2/libssh2/releases/download/libssh2-1.9.0/libssh2-1.9.0.tar.gz",
+        ],
+    )
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/BUILD.bazel
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/Cargo.Bazel.lock b/third_party/rules_rust/examples/crate_universe/multi_package/Cargo.Bazel.lock
new file mode 100644
index 0000000..12540bc
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/Cargo.Bazel.lock
@@ -0,0 +1,10787 @@
+{
+  "checksum": "cba62ac1869a36d1f714ffd077e59f027e78a09a85df999006e21db814f938f4",
+  "crates": {
+    "aho-corasick 0.7.18": {
+      "name": "aho-corasick",
+      "version": "0.7.18",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+          "sha256": "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "aho_corasick",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "aho_corasick",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.18"
+      },
+      "license": "Unlicense/MIT"
+    },
+    "anyhow 1.0.55": {
+      "name": "anyhow",
+      "version": "1.0.55",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/anyhow/1.0.55/download",
+          "sha256": "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "anyhow",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "anyhow",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "anyhow 1.0.55",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.55"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "ascii-canvas 3.0.0": {
+      "name": "ascii-canvas",
+      "version": "3.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ascii-canvas/3.0.0/download",
+          "sha256": "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ascii_canvas",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ascii_canvas",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "term 0.7.0",
+              "target": "term"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "3.0.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "assert-json-diff 2.0.1": {
+      "name": "assert-json-diff",
+      "version": "2.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/assert-json-diff/2.0.1/download",
+          "sha256": "50f1c3703dd33532d7f0ca049168930e9099ecac238e23cf932f3a69c42f06da"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "assert_json_diff",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "assert_json_diff",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.0.1"
+      },
+      "license": "MIT"
+    },
+    "async-channel 1.6.1": {
+      "name": "async-channel",
+      "version": "1.6.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-channel/1.6.1/download",
+          "sha256": "2114d64672151c0c5eaa5e131ec84a74f06e1e559830dabba01ca30605d66319"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_channel",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_channel",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "concurrent-queue 1.2.2",
+              "target": "concurrent_queue"
+            },
+            {
+              "id": "event-listener 2.5.2",
+              "target": "event_listener"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.6.1"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-executor 1.4.1": {
+      "name": "async-executor",
+      "version": "1.4.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-executor/1.4.1/download",
+          "sha256": "871f9bb5e0a22eeb7e8cf16641feb87c9dc67032ccf8ff49e772eb9941d3a965"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_executor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_executor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-task 4.2.0",
+              "target": "async_task"
+            },
+            {
+              "id": "concurrent-queue 1.2.2",
+              "target": "concurrent_queue"
+            },
+            {
+              "id": "fastrand 1.7.0",
+              "target": "fastrand"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.4.1"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-global-executor 2.0.3": {
+      "name": "async-global-executor",
+      "version": "2.0.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-global-executor/2.0.3/download",
+          "sha256": "c026b7e44f1316b567ee750fea85103f87fcb80792b860e979f221259796ca0a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_global_executor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_global_executor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "async-io",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-channel 1.6.1",
+              "target": "async_channel"
+            },
+            {
+              "id": "async-executor 1.4.1",
+              "target": "async_executor"
+            },
+            {
+              "id": "async-io 1.6.0",
+              "target": "async_io"
+            },
+            {
+              "id": "async-mutex 1.4.0",
+              "target": "async_mutex"
+            },
+            {
+              "id": "blocking 1.1.0",
+              "target": "blocking"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.0.3"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-io 1.6.0": {
+      "name": "async-io",
+      "version": "1.6.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-io/1.6.0/download",
+          "sha256": "a811e6a479f2439f0c04038796b5cfb3d2ad56c230e0f2d3f7b04d68cfee607b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_io",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_io",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "concurrent-queue 1.2.2",
+              "target": "concurrent_queue"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "parking 2.0.0",
+              "target": "parking"
+            },
+            {
+              "id": "polling 2.2.0",
+              "target": "polling"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            },
+            {
+              "id": "waker-fn 1.1.0",
+              "target": "waker_fn"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.6.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-lock 2.5.0": {
+      "name": "async-lock",
+      "version": "2.5.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-lock/2.5.0/download",
+          "sha256": "e97a171d191782fba31bb902b14ad94e24a68145032b7eedf871ab0bc0d077b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_lock",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_lock",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "event-listener 2.5.2",
+              "target": "event_listener"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.5.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-mutex 1.4.0": {
+      "name": "async-mutex",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-mutex/1.4.0/download",
+          "sha256": "479db852db25d9dbf6204e6cb6253698f175c15726470f78af0d918e99d6156e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_mutex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_mutex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "event-listener 2.5.2",
+              "target": "event_listener"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.4.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-object-pool 0.1.4": {
+      "name": "async-object-pool",
+      "version": "0.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-object-pool/0.1.4/download",
+          "sha256": "aeb901c30ebc2fc4ab46395bbfbdba9542c16559d853645d75190c3056caf3bc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_object_pool",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_object_pool",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-std 1.10.0",
+              "target": "async_std"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.4"
+      },
+      "license": "MIT"
+    },
+    "async-process 1.3.0": {
+      "name": "async-process",
+      "version": "1.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-process/1.3.0/download",
+          "sha256": "83137067e3a2a6a06d67168e49e68a0957d215410473a740cea95a2425c0b7c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_process",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_process",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "event-listener 2.5.2",
+              "target": "event_listener"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "async-io 1.6.0",
+                "target": "async_io"
+              },
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              },
+              {
+                "id": "signal-hook 0.3.13",
+                "target": "signal_hook"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "blocking 1.1.0",
+                "target": "blocking"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.3.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-std 1.10.0": {
+      "name": "async-std",
+      "version": "1.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-std/1.10.0/download",
+          "sha256": "f8056f1455169ab86dd47b47391e4ab0cbd25410a70e9fe675544f49bafaf952"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_std",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_std",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "async-channel",
+          "async-global-executor",
+          "async-io",
+          "async-lock",
+          "async-process",
+          "crossbeam-utils",
+          "default",
+          "futures-channel",
+          "futures-core",
+          "futures-io",
+          "futures-lite",
+          "gloo-timers",
+          "kv-log-macro",
+          "log",
+          "memchr",
+          "num_cpus",
+          "once_cell",
+          "pin-project-lite",
+          "pin-utils",
+          "slab",
+          "std",
+          "unstable",
+          "wasm-bindgen-futures"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-channel 1.6.1",
+              "target": "async_channel"
+            },
+            {
+              "id": "async-lock 2.5.0",
+              "target": "async_lock"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "crossbeam_utils"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-io 0.3.21",
+              "target": "futures_io"
+            },
+            {
+              "id": "kv-log-macro 1.0.7",
+              "target": "kv_log_macro"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "pin-utils 0.1.0",
+              "target": "pin_utils"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            }
+          ],
+          "selects": {
+            "cfg(not(target_os = \"unknown\"))": [
+              {
+                "id": "async-global-executor 2.0.3",
+                "target": "async_global_executor"
+              },
+              {
+                "id": "async-io 1.6.0",
+                "target": "async_io"
+              },
+              {
+                "id": "async-process 1.3.0",
+                "target": "async_process"
+              },
+              {
+                "id": "futures-lite 1.12.0",
+                "target": "futures_lite"
+              }
+            ],
+            "cfg(target_arch = \"wasm32\")": [
+              {
+                "id": "futures-channel 0.3.21",
+                "target": "futures_channel"
+              },
+              {
+                "id": "gloo-timers 0.2.3",
+                "target": "gloo_timers"
+              },
+              {
+                "id": "wasm-bindgen-futures 0.4.29",
+                "target": "wasm_bindgen_futures"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.10.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "async-task 4.2.0": {
+      "name": "async-task",
+      "version": "4.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-task/4.2.0/download",
+          "sha256": "30696a84d817107fc028e049980e09d5e140e8da8f1caeb17e8e950658a3cea9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "async_task",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_task",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "4.2.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "async-trait 0.1.52": {
+      "name": "async-trait",
+      "version": "0.1.52",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-trait/0.1.52/download",
+          "sha256": "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "async_trait",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_trait",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-trait 0.1.52",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.52"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "atomic-waker 1.0.0": {
+      "name": "atomic-waker",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atomic-waker/1.0.0/download",
+          "sha256": "065374052e7df7ee4047b1160cca5e1467a12351a40b3da123c870ba0b8eda2a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atomic_waker",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atomic_waker",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "atty 0.2.14": {
+      "name": "atty",
+      "version": "0.2.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/atty/0.2.14/download",
+          "sha256": "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "atty",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "atty",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"hermit\")": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.14"
+      },
+      "license": "MIT"
+    },
+    "autocfg 1.1.0": {
+      "name": "autocfg",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/autocfg/1.1.0/download",
+          "sha256": "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "autocfg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "autocfg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "base64 0.13.0": {
+      "name": "base64",
+      "version": "0.13.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/base64/0.13.0/download",
+          "sha256": "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "base64",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "base64",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.13.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "basic-cookies 0.1.4": {
+      "name": "basic-cookies",
+      "version": "0.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/basic-cookies/0.1.4/download",
+          "sha256": "cb53b6b315f924c7f113b162e53b3901c05fc9966baf84d201dfcc7432a4bb38"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "basic_cookies",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "basic_cookies",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "basic-cookies 0.1.4",
+              "target": "build_script_build"
+            },
+            {
+              "id": "lalrpop-util 0.19.7",
+              "target": "lalrpop_util"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lalrpop 0.19.7",
+              "target": "lalrpop"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT"
+    },
+    "bit-set 0.5.2": {
+      "name": "bit-set",
+      "version": "0.5.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bit-set/0.5.2/download",
+          "sha256": "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bit_set",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bit_set",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bit-vec 0.6.3",
+              "target": "bit_vec"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.5.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "bit-vec 0.6.3": {
+      "name": "bit-vec",
+      "version": "0.6.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bit-vec/0.6.3/download",
+          "sha256": "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bit_vec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bit_vec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.6.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "block-buffer 0.9.0": {
+      "name": "block-buffer",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/block-buffer/0.9.0/download",
+          "sha256": "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "block_buffer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "block_buffer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "generic_array"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "blocking 1.1.0": {
+      "name": "blocking",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/blocking/1.1.0/download",
+          "sha256": "046e47d4b2d391b1f6f8b407b1deb8dee56c1852ccd868becf2710f601b5f427"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "blocking",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "blocking",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-channel 1.6.1",
+              "target": "async_channel"
+            },
+            {
+              "id": "async-task 4.2.0",
+              "target": "async_task"
+            },
+            {
+              "id": "atomic-waker 1.0.0",
+              "target": "atomic_waker"
+            },
+            {
+              "id": "fastrand 1.7.0",
+              "target": "fastrand"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "bumpalo 3.9.1": {
+      "name": "bumpalo",
+      "version": "3.9.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bumpalo/3.9.1/download",
+          "sha256": "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bumpalo",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bumpalo",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "3.9.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "bytes 1.1.0": {
+      "name": "bytes",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bytes/1.1.0/download",
+          "sha256": "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bytes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bytes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.1.0"
+      },
+      "license": "MIT"
+    },
+    "cache-padded 1.2.0": {
+      "name": "cache-padded",
+      "version": "1.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cache-padded/1.2.0/download",
+          "sha256": "c1db59621ec70f09c5e9b597b220c7a2b43611f4710dc03ceb8748637775692c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cache_padded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cache_padded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.2.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "castaway 0.1.2": {
+      "name": "castaway",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/castaway/0.1.2/download",
+          "sha256": "a2698f953def977c68f935bb0dfa959375ad4638570e969e2f1e9f433cbf1af6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "castaway",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "castaway",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "license": "MIT"
+    },
+    "cc 1.0.73": {
+      "name": "cc",
+      "version": "1.0.73",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cc/1.0.73/download",
+          "sha256": "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "gcc-shim",
+            "crate_root": "src/bin/gcc-shim.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.73"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "concurrent-queue 1.2.2": {
+      "name": "concurrent-queue",
+      "version": "1.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/concurrent-queue/1.2.2/download",
+          "sha256": "30ed07550be01594c6026cff2a1d7fe9c8f683caa798e12b68694ac9e88286a3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "concurrent_queue",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "concurrent_queue",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cache-padded 1.2.0",
+              "target": "cache_padded"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.2.2"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "core-foundation 0.9.3": {
+      "name": "core-foundation",
+      "version": "0.9.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/core-foundation/0.9.3/download",
+          "sha256": "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "core_foundation",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "core_foundation",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "core-foundation-sys 0.8.3",
+              "target": "core_foundation_sys"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.9.3"
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "core-foundation-sys 0.8.3": {
+      "name": "core-foundation-sys",
+      "version": "0.8.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/core-foundation-sys/0.8.3/download",
+          "sha256": "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "core_foundation_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "core_foundation_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "core-foundation-sys 0.8.3",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.8.3"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "crossbeam-utils 0.8.7": {
+      "name": "crossbeam-utils",
+      "version": "0.8.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crossbeam-utils/0.8.7/download",
+          "sha256": "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crossbeam_utils",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crossbeam_utils",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lazy_static",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "crunchy 0.2.2": {
+      "name": "crunchy",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/crunchy/0.2.2/download",
+          "sha256": "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "crunchy",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "crunchy",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "limit_128"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "crunchy 0.2.2",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT"
+    },
+    "ctor 0.1.21": {
+      "name": "ctor",
+      "version": "0.1.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ctor/0.1.21/download",
+          "sha256": "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "ctor",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ctor",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.21"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "curl 0.4.42": {
+      "name": "curl",
+      "version": "0.4.42",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/curl/0.4.42/download",
+          "sha256": "7de97b894edd5b5bcceef8b78d7da9b75b1d2f2f9a910569d0bde3dd31d84939"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "curl",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "curl",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "http2",
+          "openssl-probe",
+          "openssl-sys",
+          "ssl",
+          "static-curl"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "curl 0.4.42",
+              "target": "build_script_build"
+            },
+            {
+              "id": "curl-sys 0.4.52+curl-7.81.0",
+              "target": "curl_sys"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            }
+          ],
+          "selects": {
+            "cfg(all(unix, not(target_os = \"macos\")))": [
+              {
+                "id": "openssl-probe 0.1.5",
+                "target": "openssl_probe"
+              },
+              {
+                "id": "openssl-sys 0.9.72",
+                "target": "openssl_sys"
+              }
+            ],
+            "cfg(target_env = \"msvc\")": [
+              {
+                "id": "schannel 0.1.19",
+                "target": "schannel"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.4.42"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "curl-sys 0.4.52+curl-7.81.0",
+              "target": "curl_sys"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT"
+    },
+    "curl-sys 0.4.52+curl-7.81.0": {
+      "name": "curl-sys",
+      "version": "0.4.52+curl-7.81.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/curl-sys/0.4.52+curl-7.81.0/download",
+          "sha256": "14b8c2d1023ea5fded5b7b892e4b8e95f70038a421126a056761a84246a28971"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "curl_sys",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "curl_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "http2",
+          "libnghttp2-sys",
+          "openssl-sys",
+          "ssl",
+          "static-curl"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "libnghttp2-sys 0.1.7+1.45.0",
+              "target": "libnghttp2_sys"
+            },
+            {
+              "id": "libz-sys 1.1.4",
+              "target": "libz_sys"
+            }
+          ],
+          "selects": {
+            "cfg(all(unix, not(target_os = \"macos\")))": [
+              {
+                "id": "openssl-sys 0.9.72",
+                "target": "openssl_sys"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "extra_deps": [
+          "@curl",
+          "@libssh2"
+        ],
+        "edition": "2018",
+        "version": "0.4.52+curl-7.81.0"
+      },
+      "license": "MIT"
+    },
+    "diff 0.1.12": {
+      "name": "diff",
+      "version": "0.1.12",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/diff/0.1.12/download",
+          "sha256": "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "diff",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "diff",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.12"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "digest 0.9.0": {
+      "name": "digest",
+      "version": "0.9.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/digest/0.9.0/download",
+          "sha256": "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "digest",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "digest",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "generic_array"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "direct-cargo-bazel-deps 0.0.1": {
+      "name": "direct-cargo-bazel-deps",
+      "version": "0.0.1",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "direct_cargo_bazel_deps",
+            "crate_root": ".direct_cargo_bazel_deps.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "direct_cargo_bazel_deps",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.0.1"
+      },
+      "license": null
+    },
+    "dirs-next 2.0.0": {
+      "name": "dirs-next",
+      "version": "2.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/dirs-next/2.0.0/download",
+          "sha256": "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "dirs_next",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "dirs_next",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "dirs-sys-next 0.1.2",
+              "target": "dirs_sys_next"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.0.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "dirs-sys-next 0.1.2": {
+      "name": "dirs-sys-next",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/dirs-sys-next/0.1.2/download",
+          "sha256": "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "dirs_sys_next",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "dirs_sys_next",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"redox\")": [
+              {
+                "id": "redox_users 0.4.0",
+                "target": "redox_users"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "either 1.6.1": {
+      "name": "either",
+      "version": "1.6.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/either/1.6.1/download",
+          "sha256": "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "either",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "either",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.6.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "ena 0.14.0": {
+      "name": "ena",
+      "version": "0.14.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ena/0.14.0/download",
+          "sha256": "d7402b94a93c24e742487327a7cd839dc9d36fec9de9fb25b09f2dae459f36c3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ena",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ena",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.14.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "encoding_rs 0.8.30": {
+      "name": "encoding_rs",
+      "version": "0.8.30",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/encoding_rs/0.8.30/download",
+          "sha256": "7896dc8abb250ffdda33912550faa54c88ec8b998dec0b2c55ab224921ce11df"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "encoding_rs",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "encoding_rs",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "encoding_rs 0.8.30",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.30"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": null
+    },
+    "event-listener 2.5.2": {
+      "name": "event-listener",
+      "version": "2.5.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/event-listener/2.5.2/download",
+          "sha256": "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "event_listener",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "event_listener",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "2.5.2"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "fastrand 1.7.0": {
+      "name": "fastrand",
+      "version": "1.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fastrand/1.7.0/download",
+          "sha256": "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fastrand",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fastrand",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_arch = \"wasm32\")": [
+              {
+                "id": "instant 0.1.12",
+                "target": "instant"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.7.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "fixedbitset 0.2.0": {
+      "name": "fixedbitset",
+      "version": "0.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fixedbitset/0.2.0/download",
+          "sha256": "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fixedbitset",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fixedbitset",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "fnv 1.0.7": {
+      "name": "fnv",
+      "version": "1.0.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fnv/1.0.7/download",
+          "sha256": "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fnv",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fnv",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "1.0.7"
+      },
+      "license": "Apache-2.0 / MIT"
+    },
+    "foreign-types 0.3.2": {
+      "name": "foreign-types",
+      "version": "0.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/foreign-types/0.3.2/download",
+          "sha256": "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "foreign_types",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "foreign_types",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "foreign-types-shared 0.1.1",
+              "target": "foreign_types_shared"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "foreign-types-shared 0.1.1": {
+      "name": "foreign-types-shared",
+      "version": "0.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/foreign-types-shared/0.1.1/download",
+          "sha256": "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "foreign_types_shared",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "foreign_types_shared",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "form_urlencoded 1.0.1": {
+      "name": "form_urlencoded",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download",
+          "sha256": "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "form_urlencoded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "form_urlencoded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "futures-channel 0.3.21": {
+      "name": "futures-channel",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-channel/0.3.21/download",
+          "sha256": "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_channel",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_channel",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-channel 0.3.21",
+              "target": "build_script_build"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-core 0.3.21": {
+      "name": "futures-core",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-core/0.3.21/download",
+          "sha256": "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-core 0.3.21",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-io 0.3.21": {
+      "name": "futures-io",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-io/0.3.21/download",
+          "sha256": "fc4045962a5a5e935ee2fdedaa4e08284547402885ab326734432bed5d12966b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_io",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_io",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-lite 1.12.0": {
+      "name": "futures-lite",
+      "version": "1.12.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-lite/1.12.0/download",
+          "sha256": "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_lite",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_lite",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "fastrand",
+          "futures-io",
+          "memchr",
+          "parking",
+          "std",
+          "waker-fn"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "fastrand 1.7.0",
+              "target": "fastrand"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-io 0.3.21",
+              "target": "futures_io"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "parking 2.0.0",
+              "target": "parking"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "waker-fn 1.1.0",
+              "target": "waker_fn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.12.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "futures-macro 0.3.21": {
+      "name": "futures-macro",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-macro/0.3.21/download",
+          "sha256": "33c1e13800337f4d4d7a316bf45a567dbcb6ffe087f16424852d97e97a91f512"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "futures_macro",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_macro",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-sink 0.3.21": {
+      "name": "futures-sink",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-sink/0.3.21/download",
+          "sha256": "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_sink",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_sink",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-task 0.3.21": {
+      "name": "futures-task",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-task/0.3.21/download",
+          "sha256": "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_task",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_task",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-task 0.3.21",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-util 0.3.21": {
+      "name": "futures-util",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-util/0.3.21/download",
+          "sha256": "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "async-await",
+          "async-await-macro",
+          "default",
+          "futures-io",
+          "futures-macro",
+          "io",
+          "memchr",
+          "slab",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-io 0.3.21",
+              "target": "futures_io"
+            },
+            {
+              "id": "futures-task 0.3.21",
+              "target": "futures_task"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "build_script_build"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "pin-utils 0.1.0",
+              "target": "pin_utils"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "futures-macro 0.3.21",
+              "target": "futures_macro"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "generic-array 0.14.5": {
+      "name": "generic-array",
+      "version": "0.14.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/generic-array/0.14.5/download",
+          "sha256": "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "generic_array",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "generic_array",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "generic-array 0.14.5",
+              "target": "build_script_build"
+            },
+            {
+              "id": "typenum 1.15.0",
+              "target": "typenum"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.14.5"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT"
+    },
+    "getrandom 0.2.5": {
+      "name": "getrandom",
+      "version": "0.2.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/getrandom/0.2.5/download",
+          "sha256": "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "getrandom",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "getrandom",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"wasi\")": [
+              {
+                "id": "wasi 0.10.2+wasi-snapshot-preview1",
+                "target": "wasi"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.2.5"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "gloo-timers 0.2.3": {
+      "name": "gloo-timers",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/gloo-timers/0.2.3/download",
+          "sha256": "4d12a7f4e95cfe710f1d624fb1210b7d961a5fb05c4fd942f4feab06e61f590e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "gloo_timers",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "gloo_timers",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "futures",
+          "futures-channel",
+          "futures-core"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-channel 0.3.21",
+              "target": "futures_channel"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "js-sys 0.3.56",
+              "target": "js_sys"
+            },
+            {
+              "id": "wasm-bindgen 0.2.79",
+              "target": "wasm_bindgen"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "h2 0.3.11": {
+      "name": "h2",
+      "version": "0.3.11",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/h2/0.3.11/download",
+          "sha256": "d9f1f717ddc7b2ba36df7e871fd88db79326551d3d6f1fc406fbfd28b582ff8e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "h2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "h2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "fnv 1.0.7",
+              "target": "fnv"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-sink 0.3.21",
+              "target": "futures_sink"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "indexmap"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tokio-util 0.6.9",
+              "target": "tokio_util"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.11"
+      },
+      "license": "MIT"
+    },
+    "hashbrown 0.11.2": {
+      "name": "hashbrown",
+      "version": "0.11.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hashbrown/0.11.2/download",
+          "sha256": "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hashbrown",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hashbrown",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "raw"
+        ],
+        "edition": "2018",
+        "version": "0.11.2"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "hex-literal 0.3.4": {
+      "name": "hex-literal",
+      "version": "0.3.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hex-literal/0.3.4/download",
+          "sha256": "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "hex_literal",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hex_literal",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "http 0.2.6": {
+      "name": "http",
+      "version": "0.2.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/http/0.2.6/download",
+          "sha256": "31f4c6746584866f0feabcc69893c5b51beef3831656a968ed7ae254cdc4fd03"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "http",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "http",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "fnv 1.0.7",
+              "target": "fnv"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.6"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "http-body 0.4.4": {
+      "name": "http-body",
+      "version": "0.4.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/http-body/0.4.4/download",
+          "sha256": "1ff4f84919677303da5f147645dbea6b1881f368d03ac84e1dc09031ebd7b2c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "http_body",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "http_body",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.4"
+      },
+      "license": "MIT"
+    },
+    "httparse 1.6.0": {
+      "name": "httparse",
+      "version": "1.6.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/httparse/1.6.0/download",
+          "sha256": "9100414882e15fb7feccb4897e5f0ff0ff1ca7d1a86a23208ada4d7a18e6c6c4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "httparse",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "httparse",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "httparse 1.6.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.6.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "httpdate 1.0.2": {
+      "name": "httpdate",
+      "version": "1.0.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/httpdate/1.0.2/download",
+          "sha256": "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "httpdate",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "httpdate",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "httpmock 0.6.6": {
+      "name": "httpmock",
+      "version": "0.6.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/httpmock/0.6.6/download",
+          "sha256": "c159c4fc205e6c1a9b325cb7ec135d13b5f47188ce175dabb76ec847f331d9bd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "httpmock",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "httpmock",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "httpmock",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "basic-cookies",
+          "cookies",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "assert-json-diff 2.0.1",
+              "target": "assert_json_diff"
+            },
+            {
+              "id": "async-object-pool 0.1.4",
+              "target": "async_object_pool"
+            },
+            {
+              "id": "base64 0.13.0",
+              "target": "base64"
+            },
+            {
+              "id": "basic-cookies 0.1.4",
+              "target": "basic_cookies"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "crossbeam_utils"
+            },
+            {
+              "id": "form_urlencoded 1.0.1",
+              "target": "form_urlencoded"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "hyper 0.14.17",
+              "target": "hyper"
+            },
+            {
+              "id": "isahc 1.6.0",
+              "target": "isahc"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "levenshtein 1.0.5",
+              "target": "levenshtein"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "serde_regex 1.1.0",
+              "target": "serde_regex"
+            },
+            {
+              "id": "similar 2.1.0",
+              "target": "similar"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "url 2.2.2",
+              "target": "url"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "async-trait 0.1.52",
+              "target": "async_trait"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.6.6"
+      },
+      "license": "MIT"
+    },
+    "hyper 0.14.17": {
+      "name": "hyper",
+      "version": "0.14.17",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hyper/0.14.17/download",
+          "sha256": "043f0e083e9901b6cc658a77d1eb86f4fc650bbb977a4337dd63192826aa85dd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hyper",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hyper",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "client",
+          "default",
+          "h2",
+          "http1",
+          "http2",
+          "runtime",
+          "server",
+          "socket2",
+          "tcp"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-channel 0.3.21",
+              "target": "futures_channel"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "h2 0.3.11",
+              "target": "h2"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "http-body 0.4.4",
+              "target": "http_body"
+            },
+            {
+              "id": "httparse 1.6.0",
+              "target": "httparse"
+            },
+            {
+              "id": "httpdate 1.0.2",
+              "target": "httpdate"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tower-service 0.3.1",
+              "target": "tower_service"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            },
+            {
+              "id": "want 0.3.0",
+              "target": "want"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.14.17"
+      },
+      "license": "MIT"
+    },
+    "hyper-tls 0.5.0": {
+      "name": "hyper-tls",
+      "version": "0.5.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hyper-tls/0.5.0/download",
+          "sha256": "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hyper_tls",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hyper_tls",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "hyper 0.14.17",
+              "target": "hyper"
+            },
+            {
+              "id": "native-tls 0.2.8",
+              "target": "native_tls"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tokio-native-tls 0.3.0",
+              "target": "tokio_native_tls"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.5.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "idna 0.2.3": {
+      "name": "idna",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/idna/0.2.3/download",
+          "sha256": "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "idna",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "idna",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "unicode-bidi 0.3.7",
+              "target": "unicode_bidi"
+            },
+            {
+              "id": "unicode-normalization 0.1.19",
+              "target": "unicode_normalization"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "indexmap 1.8.0": {
+      "name": "indexmap",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/indexmap/1.8.0/download",
+          "sha256": "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "indexmap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "indexmap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "hashbrown 0.11.2",
+              "target": "hashbrown"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "instant 0.1.12": {
+      "name": "instant",
+      "version": "0.1.12",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/instant/0.1.12/download",
+          "sha256": "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "instant",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "instant",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.12"
+      },
+      "license": "BSD-3-Clause"
+    },
+    "ipnet 2.4.0": {
+      "name": "ipnet",
+      "version": "2.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ipnet/2.4.0/download",
+          "sha256": "35e70ee094dc02fd9c13fdad4940090f22dbd6ac7c9e7094a46cf0232a50bc7c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ipnet",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ipnet",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "2.4.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "isahc 1.6.0": {
+      "name": "isahc",
+      "version": "1.6.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/isahc/1.6.0/download",
+          "sha256": "d140e84730d325378912ede32d7cd53ef1542725503b3353e5ec8113c7c6f588"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "isahc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "isahc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "encoding_rs",
+          "http2",
+          "mime",
+          "static-curl",
+          "text-decoding"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-channel 1.6.1",
+              "target": "async_channel"
+            },
+            {
+              "id": "castaway 0.1.2",
+              "target": "castaway"
+            },
+            {
+              "id": "crossbeam-utils 0.8.7",
+              "target": "crossbeam_utils"
+            },
+            {
+              "id": "curl 0.4.42",
+              "target": "curl"
+            },
+            {
+              "id": "curl-sys 0.4.52+curl-7.81.0",
+              "target": "curl_sys"
+            },
+            {
+              "id": "encoding_rs 0.8.30",
+              "target": "encoding_rs"
+            },
+            {
+              "id": "event-listener 2.5.2",
+              "target": "event_listener"
+            },
+            {
+              "id": "futures-lite 1.12.0",
+              "target": "futures_lite"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "isahc 1.6.0",
+              "target": "build_script_build"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "mime 0.3.16",
+              "target": "mime"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "polling 2.2.0",
+              "target": "polling"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            },
+            {
+              "id": "sluice 0.5.5",
+              "target": "sluice"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            },
+            {
+              "id": "tracing-futures 0.2.5",
+              "target": "tracing_futures"
+            },
+            {
+              "id": "url 2.2.2",
+              "target": "url"
+            },
+            {
+              "id": "waker-fn 1.1.0",
+              "target": "waker_fn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.6.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT"
+    },
+    "itertools 0.10.3": {
+      "name": "itertools",
+      "version": "0.10.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/itertools/0.10.3/download",
+          "sha256": "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "itertools",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "itertools",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "use_alloc",
+          "use_std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "either 1.6.1",
+              "target": "either"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "itoa 1.0.1": {
+      "name": "itoa",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/itoa/1.0.1/download",
+          "sha256": "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "itoa",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "itoa",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "js-sys 0.3.56": {
+      "name": "js-sys",
+      "version": "0.3.56",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/js-sys/0.3.56/download",
+          "sha256": "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "js_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "js_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "wasm-bindgen 0.2.79",
+              "target": "wasm_bindgen"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.56"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "kv-log-macro 1.0.7": {
+      "name": "kv-log-macro",
+      "version": "1.0.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/kv-log-macro/1.0.7/download",
+          "sha256": "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "kv_log_macro",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "kv_log_macro",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.7"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "lalrpop 0.19.7": {
+      "name": "lalrpop",
+      "version": "0.19.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lalrpop/0.19.7/download",
+          "sha256": "852b75a095da6b69da8c5557731c3afd06525d4f655a4fc1c799e2ec8bc4dce4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lalrpop",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "Binary": {
+            "crate_name": "lalrpop",
+            "crate_root": "src/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lalrpop",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lexer",
+          "pico-args"
+        ],
+        "data_glob": [
+          "**/*.lalrpop"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ascii-canvas 3.0.0",
+              "target": "ascii_canvas"
+            },
+            {
+              "id": "atty 0.2.14",
+              "target": "atty"
+            },
+            {
+              "id": "bit-set 0.5.2",
+              "target": "bit_set"
+            },
+            {
+              "id": "diff 0.1.12",
+              "target": "diff"
+            },
+            {
+              "id": "ena 0.14.0",
+              "target": "ena"
+            },
+            {
+              "id": "itertools 0.10.3",
+              "target": "itertools"
+            },
+            {
+              "id": "lalrpop-util 0.19.7",
+              "target": "lalrpop_util"
+            },
+            {
+              "id": "petgraph 0.5.1",
+              "target": "petgraph"
+            },
+            {
+              "id": "pico-args 0.4.2",
+              "target": "pico_args"
+            },
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "regex-syntax 0.6.25",
+              "target": "regex_syntax"
+            },
+            {
+              "id": "string_cache 0.8.3",
+              "target": "string_cache"
+            },
+            {
+              "id": "term 0.7.0",
+              "target": "term"
+            },
+            {
+              "id": "tiny-keccak 2.0.2",
+              "target": "tiny_keccak"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.19.7"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "lalrpop-util 0.19.7": {
+      "name": "lalrpop-util",
+      "version": "0.19.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lalrpop-util/0.19.7/download",
+          "sha256": "d6d265705249fe209280676d8f68887859fa42e1d34f342fc05bd47726a5e188"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lalrpop_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lalrpop_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lexer",
+          "regex",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.19.7"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "lazy_static 1.4.0": {
+      "name": "lazy_static",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+          "sha256": "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lazy_static",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lazy_static",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "levenshtein 1.0.5": {
+      "name": "levenshtein",
+      "version": "1.0.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/levenshtein/1.0.5/download",
+          "sha256": "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "levenshtein",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "levenshtein",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.0.5"
+      },
+      "license": "MIT"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "libnghttp2-sys 0.1.7+1.45.0": {
+      "name": "libnghttp2-sys",
+      "version": "0.1.7+1.45.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libnghttp2-sys/0.1.7+1.45.0/download",
+          "sha256": "57ed28aba195b38d5ff02b9170cbff627e336a20925e43b4945390401c5dc93f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libnghttp2_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libnghttp2_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "data_glob": [
+          "nghttp2/**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "libnghttp2-sys 0.1.7+1.45.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.7+1.45.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**",
+          "nghttp2/**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cc 1.0.73",
+              "target": "cc"
+            }
+          ],
+          "selects": {}
+        },
+        "links": "nghttp2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libz-sys 1.1.4": {
+      "name": "libz-sys",
+      "version": "1.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libz-sys/1.1.4/download",
+          "sha256": "df2bf61678a0a521c3f7daf815d2e6717d85a272a7dcd02c9768272b32bd1e2a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libz_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libz_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "libc"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "libz-sys 1.1.4",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.1.4"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cc 1.0.73",
+              "target": "cc"
+            },
+            {
+              "id": "pkg-config 0.3.24",
+              "target": "pkg_config"
+            }
+          ],
+          "selects": {
+            "cfg(target_env = \"msvc\")": [
+              {
+                "id": "vcpkg 0.2.15",
+                "target": "vcpkg"
+              }
+            ]
+          }
+        },
+        "links": "z"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "lock_api 0.4.6": {
+      "name": "lock_api",
+      "version": "0.4.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lock_api/0.4.6/download",
+          "sha256": "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lock_api",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lock_api",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "scopeguard 1.1.0",
+              "target": "scopeguard"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.6"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "log 0.4.14": {
+      "name": "log",
+      "version": "0.4.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/log/0.4.14/download",
+          "sha256": "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "kv_unstable",
+          "value-bag"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "build_script_build"
+            },
+            {
+              "id": "value-bag 1.0.0-alpha.8",
+              "target": "value_bag"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "matches 0.1.9": {
+      "name": "matches",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/matches/0.1.9/download",
+          "sha256": "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "matches",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "matches",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT"
+    },
+    "md-5 0.9.1": {
+      "name": "md-5",
+      "version": "0.9.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/md-5/0.9.1/download",
+          "sha256": "7b5a279bb9607f9f53c22d496eade00d138d1bdcccd07d74650387cf94942a15"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "md5",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "md5",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "block-buffer 0.9.0",
+              "target": "block_buffer"
+            },
+            {
+              "id": "digest 0.9.0",
+              "target": "digest"
+            },
+            {
+              "id": "opaque-debug 0.3.0",
+              "target": "opaque_debug"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.9.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "memchr 2.4.1": {
+      "name": "memchr",
+      "version": "2.4.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+          "sha256": "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "memchr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "memchr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.4.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Unlicense/MIT"
+    },
+    "mime 0.3.16": {
+      "name": "mime",
+      "version": "0.3.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/mime/0.3.16/download",
+          "sha256": "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "mime",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "mime",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.16"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "mio 0.8.0": {
+      "name": "mio",
+      "version": "0.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/mio/0.8.0/download",
+          "sha256": "ba272f85fa0b41fc91872be579b3bbe0f56b792aa361a380eb669469f68dafb2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "mio",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "mio",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "net",
+          "os-ext",
+          "os-poll"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "miow 0.3.7",
+                "target": "miow"
+              },
+              {
+                "id": "ntapi 0.3.7",
+                "target": "ntapi"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.0"
+      },
+      "license": "MIT"
+    },
+    "miow 0.3.7": {
+      "name": "miow",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/miow/0.3.7/download",
+          "sha256": "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "miow",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "miow",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "native-tls 0.2.8": {
+      "name": "native-tls",
+      "version": "0.2.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/native-tls/0.2.8/download",
+          "sha256": "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "native_tls",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "native_tls",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "native-tls 0.2.8",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "cfg(any(target_os = \"macos\", target_os = \"ios\"))": [
+              {
+                "id": "lazy_static 1.4.0",
+                "target": "lazy_static"
+              },
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              },
+              {
+                "id": "security-framework 2.6.1",
+                "target": "security_framework"
+              },
+              {
+                "id": "security-framework-sys 2.6.1",
+                "target": "security_framework_sys"
+              },
+              {
+                "id": "tempfile 3.3.0",
+                "target": "tempfile"
+              }
+            ],
+            "cfg(not(any(target_os = \"windows\", target_os = \"macos\", target_os = \"ios\")))": [
+              {
+                "id": "log 0.4.14",
+                "target": "log"
+              },
+              {
+                "id": "openssl 0.10.38",
+                "target": "openssl"
+              },
+              {
+                "id": "openssl-probe 0.1.5",
+                "target": "openssl_probe"
+              },
+              {
+                "id": "openssl-sys 0.9.72",
+                "target": "openssl_sys"
+              }
+            ],
+            "cfg(target_os = \"windows\")": [
+              {
+                "id": "schannel 0.1.19",
+                "target": "schannel"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.2.8"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "new_debug_unreachable 1.0.4": {
+      "name": "new_debug_unreachable",
+      "version": "1.0.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/new_debug_unreachable/1.0.4/download",
+          "sha256": "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "debug_unreachable",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "debug_unreachable",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.4"
+      },
+      "license": "MIT"
+    },
+    "ntapi 0.3.7": {
+      "name": "ntapi",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ntapi/0.3.7/download",
+          "sha256": "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ntapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ntapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "user"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ntapi 0.3.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "num_cpus 1.13.1": {
+      "name": "num_cpus",
+      "version": "1.13.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num_cpus/1.13.1/download",
+          "sha256": "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_cpus",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_cpus",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(not(windows))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "1.13.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "once_cell 1.10.0": {
+      "name": "once_cell",
+      "version": "1.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/once_cell/1.10.0/download",
+          "sha256": "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "once_cell",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "once_cell",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "race",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.10.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "opaque-debug 0.3.0": {
+      "name": "opaque-debug",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/opaque-debug/0.3.0/download",
+          "sha256": "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "opaque_debug",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "opaque_debug",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "openssl 0.10.38": {
+      "name": "openssl",
+      "version": "0.10.38",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/openssl/0.10.38/download",
+          "sha256": "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "openssl",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "openssl",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "foreign-types 0.3.2",
+              "target": "foreign_types"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "openssl 0.10.38",
+              "target": "build_script_build"
+            },
+            {
+              "id": "openssl-sys 0.9.72",
+              "target": "openssl_sys",
+              "alias": "ffi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.38"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "openssl-sys 0.9.72",
+              "target": "openssl_sys",
+              "alias": "ffi"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0"
+    },
+    "openssl-probe 0.1.5": {
+      "name": "openssl-probe",
+      "version": "0.1.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/openssl-probe/0.1.5/download",
+          "sha256": "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "openssl_probe",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "openssl_probe",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.5"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "openssl-sys 0.9.72": {
+      "name": "openssl-sys",
+      "version": "0.9.72",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/openssl-sys/0.9.72/download",
+          "sha256": "7e46109c383602735fa0a2e48dd2b7c892b048e1bf69e5c3b1d804b7d9c203cb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "openssl_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_main",
+            "crate_root": "build/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "openssl_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "data": {
+          "common": [
+            "@openssl"
+          ],
+          "selects": {}
+        },
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "openssl-sys 0.9.72",
+              "target": "build_script_main"
+            }
+          ],
+          "selects": {}
+        },
+        "extra_deps": [
+          "@openssl"
+        ],
+        "edition": "2015",
+        "version": "0.9.72"
+      },
+      "build_script_attrs": {
+        "data": {
+          "common": [
+            "@openssl//:gen_dir",
+            "@openssl//:openssl"
+          ],
+          "selects": {}
+        },
+        "data_glob": [
+          "**",
+          "build/**/*.c"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            },
+            {
+              "id": "cc 1.0.73",
+              "target": "cc"
+            },
+            {
+              "id": "pkg-config 0.3.24",
+              "target": "pkg_config"
+            }
+          ],
+          "selects": {
+            "cfg(target_env = \"msvc\")": [
+              {
+                "id": "vcpkg 0.2.15",
+                "target": "vcpkg"
+              }
+            ]
+          }
+        },
+        "build_script_env": {
+          "common": {
+            "OPENSSL_DIR": "$(execpath @openssl//:gen_dir)",
+            "OPENSSL_STATIC": "1"
+          },
+          "selects": {}
+        },
+        "links": "openssl"
+      },
+      "license": "MIT"
+    },
+    "parking 2.0.0": {
+      "name": "parking",
+      "version": "2.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parking/2.0.0/download",
+          "sha256": "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parking",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parking",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "2.0.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "parking_lot 0.11.2": {
+      "name": "parking_lot",
+      "version": "0.11.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parking_lot/0.11.2/download",
+          "sha256": "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parking_lot",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parking_lot",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "instant 0.1.12",
+              "target": "instant"
+            },
+            {
+              "id": "lock_api 0.4.6",
+              "target": "lock_api"
+            },
+            {
+              "id": "parking_lot_core 0.8.5",
+              "target": "parking_lot_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.11.2"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "parking_lot_core 0.8.5": {
+      "name": "parking_lot_core",
+      "version": "0.8.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parking_lot_core/0.8.5/download",
+          "sha256": "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parking_lot_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parking_lot_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "instant 0.1.12",
+              "target": "instant"
+            },
+            {
+              "id": "parking_lot_core 0.8.5",
+              "target": "build_script_build"
+            },
+            {
+              "id": "smallvec 1.8.0",
+              "target": "smallvec"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"redox\")": [
+              {
+                "id": "redox_syscall 0.2.11",
+                "target": "syscall"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.5"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "percent-encoding 2.1.0": {
+      "name": "percent-encoding",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/percent-encoding/2.1.0/download",
+          "sha256": "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "percent_encoding",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "percent_encoding",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "2.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "petgraph 0.5.1": {
+      "name": "petgraph",
+      "version": "0.5.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/petgraph/0.5.1/download",
+          "sha256": "467d164a6de56270bd7c4d070df81d07beace25012d5103ced4e9ff08d6afdb7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "petgraph",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "petgraph",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "fixedbitset 0.2.0",
+              "target": "fixedbitset"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "indexmap"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.5.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "phf_shared 0.10.0": {
+      "name": "phf_shared",
+      "version": "0.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/phf_shared/0.10.0/download",
+          "sha256": "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "phf_shared",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "phf_shared",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "siphasher 0.3.10",
+              "target": "siphasher"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.10.0"
+      },
+      "license": "MIT"
+    },
+    "pico-args 0.4.2": {
+      "name": "pico-args",
+      "version": "0.4.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pico-args/0.4.2/download",
+          "sha256": "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pico_args",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pico_args",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.4.2"
+      },
+      "license": "MIT"
+    },
+    "pin-project 1.0.10": {
+      "name": "pin-project",
+      "version": "1.0.10",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project/1.0.10/download",
+          "sha256": "58ad3879ad3baf4e44784bc6a718a8698867bb991f8ce24d1bcbe2cfb4c3a75e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_project",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "pin-project-internal 1.0.10",
+              "target": "pin_project_internal"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.10"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-project-internal 1.0.10": {
+      "name": "pin-project-internal",
+      "version": "1.0.10",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project-internal/1.0.10/download",
+          "sha256": "744b6f092ba29c3650faf274db506afd39944f48420f6c86b17cfe0ee1cb36bb"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "pin_project_internal",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project_internal",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.10"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-project-lite 0.2.8": {
+      "name": "pin-project-lite",
+      "version": "0.2.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project-lite/0.2.8/download",
+          "sha256": "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_project_lite",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project_lite",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.2.8"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-utils 0.1.0": {
+      "name": "pin-utils",
+      "version": "0.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-utils/0.1.0/download",
+          "sha256": "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_utils",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_utils",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "pkg-config 0.3.24": {
+      "name": "pkg-config",
+      "version": "0.3.24",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pkg-config/0.3.24/download",
+          "sha256": "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pkg_config",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pkg_config",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.24"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pkg_a 0.1.0": {
+      "name": "pkg_a",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pkg_a",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pkg_a",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "anyhow 1.0.55",
+              "target": "anyhow"
+            },
+            {
+              "id": "reqwest 0.11.9",
+              "target": "reqwest"
+            }
+          ],
+          "selects": {}
+        },
+        "deps_dev": {
+          "common": [
+            {
+              "id": "httpmock 0.6.6",
+              "target": "httpmock"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "pkg_b 0.1.0": {
+      "name": "pkg_b",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pkg_b",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pkg_b",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "openssl 0.10.38",
+              "target": "openssl"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "pkg_c 0.1.0": {
+      "name": "pkg_c",
+      "version": "0.1.0",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pkg_c",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pkg_c",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "md-5 0.9.1",
+              "target": "md5"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps_dev": {
+          "common": [
+            {
+              "id": "hex-literal 0.3.4",
+              "target": "hex_literal"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.1.0"
+      },
+      "license": null
+    },
+    "polling 2.2.0": {
+      "name": "polling",
+      "version": "2.2.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/polling/2.2.0/download",
+          "sha256": "685404d509889fade3e86fe3a5803bca2ec09b0c0778d5ada6ec8bf7a8de5259"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "polling",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "polling",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {
+            "cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "wepoll-ffi 0.1.2",
+                "target": "wepoll_ffi"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "2.2.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "precomputed-hash 0.1.1": {
+      "name": "precomputed-hash",
+      "version": "0.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/precomputed-hash/0.1.1/download",
+          "sha256": "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "precomputed_hash",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "precomputed_hash",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.1"
+      },
+      "license": "MIT"
+    },
+    "proc-macro2 1.0.36": {
+      "name": "proc-macro2",
+      "version": "1.0.36",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro2/1.0.36/download",
+          "sha256": "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.36"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "quote 1.0.15": {
+      "name": "quote",
+      "version": "1.0.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/quote/1.0.15/download",
+          "sha256": "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "quote",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "quote",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.15"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "redox_syscall 0.2.11": {
+      "name": "redox_syscall",
+      "version": "0.2.11",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/redox_syscall/0.2.11/download",
+          "sha256": "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syscall",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syscall",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.11"
+      },
+      "license": "MIT"
+    },
+    "redox_users 0.4.0": {
+      "name": "redox_users",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/redox_users/0.4.0/download",
+          "sha256": "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "redox_users",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "redox_users",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "getrandom 0.2.5",
+              "target": "getrandom"
+            },
+            {
+              "id": "redox_syscall 0.2.11",
+              "target": "syscall"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.0"
+      },
+      "license": "MIT"
+    },
+    "regex 1.5.4": {
+      "name": "regex",
+      "version": "1.5.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex/1.5.4/download",
+          "sha256": "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "aho-corasick",
+          "default",
+          "memchr",
+          "perf",
+          "perf-cache",
+          "perf-dfa",
+          "perf-inline",
+          "perf-literal",
+          "std",
+          "unicode",
+          "unicode-age",
+          "unicode-bool",
+          "unicode-case",
+          "unicode-gencat",
+          "unicode-perl",
+          "unicode-script",
+          "unicode-segment"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "aho-corasick 0.7.18",
+              "target": "aho_corasick"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "regex-syntax 0.6.25",
+              "target": "regex_syntax"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "regex-syntax 0.6.25": {
+      "name": "regex-syntax",
+      "version": "0.6.25",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+          "sha256": "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "regex_syntax",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "regex_syntax",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "unicode",
+          "unicode-age",
+          "unicode-bool",
+          "unicode-case",
+          "unicode-gencat",
+          "unicode-perl",
+          "unicode-script",
+          "unicode-segment"
+        ],
+        "edition": "2018",
+        "version": "0.6.25"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "remove_dir_all 0.5.3": {
+      "name": "remove_dir_all",
+      "version": "0.5.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/remove_dir_all/0.5.3/download",
+          "sha256": "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "remove_dir_all",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "remove_dir_all",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.5.3"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "reqwest 0.11.9": {
+      "name": "reqwest",
+      "version": "0.11.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/reqwest/0.11.9/download",
+          "sha256": "87f242f1488a539a79bac6dbe7c8609ae43b7914b7736210f239a37cccb32525"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "reqwest",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "reqwest",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "__tls",
+          "blocking",
+          "default",
+          "default-tls",
+          "hyper-tls",
+          "json",
+          "native-tls-crate",
+          "serde_json",
+          "tokio-native-tls"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "serde_urlencoded 0.7.1",
+              "target": "serde_urlencoded"
+            },
+            {
+              "id": "url 2.2.2",
+              "target": "url"
+            }
+          ],
+          "selects": {
+            "cfg(not(target_arch = \"wasm32\"))": [
+              {
+                "id": "base64 0.13.0",
+                "target": "base64"
+              },
+              {
+                "id": "encoding_rs 0.8.30",
+                "target": "encoding_rs"
+              },
+              {
+                "id": "futures-core 0.3.21",
+                "target": "futures_core"
+              },
+              {
+                "id": "futures-util 0.3.21",
+                "target": "futures_util"
+              },
+              {
+                "id": "h2 0.3.11",
+                "target": "h2"
+              },
+              {
+                "id": "http-body 0.4.4",
+                "target": "http_body"
+              },
+              {
+                "id": "hyper 0.14.17",
+                "target": "hyper"
+              },
+              {
+                "id": "hyper-tls 0.5.0",
+                "target": "hyper_tls"
+              },
+              {
+                "id": "ipnet 2.4.0",
+                "target": "ipnet"
+              },
+              {
+                "id": "lazy_static 1.4.0",
+                "target": "lazy_static"
+              },
+              {
+                "id": "log 0.4.14",
+                "target": "log"
+              },
+              {
+                "id": "mime 0.3.16",
+                "target": "mime"
+              },
+              {
+                "id": "native-tls 0.2.8",
+                "target": "native_tls",
+                "alias": "native_tls_crate"
+              },
+              {
+                "id": "percent-encoding 2.1.0",
+                "target": "percent_encoding"
+              },
+              {
+                "id": "pin-project-lite 0.2.8",
+                "target": "pin_project_lite"
+              },
+              {
+                "id": "tokio 1.17.0",
+                "target": "tokio"
+              },
+              {
+                "id": "tokio-native-tls 0.3.0",
+                "target": "tokio_native_tls"
+              }
+            ],
+            "cfg(target_arch = \"wasm32\")": [
+              {
+                "id": "js-sys 0.3.56",
+                "target": "js_sys"
+              },
+              {
+                "id": "serde_json 1.0.79",
+                "target": "serde_json"
+              },
+              {
+                "id": "wasm-bindgen 0.2.79",
+                "target": "wasm_bindgen"
+              },
+              {
+                "id": "wasm-bindgen-futures 0.4.29",
+                "target": "wasm_bindgen_futures"
+              },
+              {
+                "id": "web-sys 0.3.56",
+                "target": "web_sys"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winreg 0.7.0",
+                "target": "winreg"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.11.9"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "rustversion 1.0.6": {
+      "name": "rustversion",
+      "version": "1.0.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/rustversion/1.0.6/download",
+          "sha256": "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "rustversion",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build/build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "rustversion",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "rustversion 1.0.6",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.6"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "ryu 1.0.9": {
+      "name": "ryu",
+      "version": "1.0.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ryu/1.0.9/download",
+          "sha256": "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ryu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ryu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.9"
+      },
+      "license": "Apache-2.0 OR BSL-1.0"
+    },
+    "schannel 0.1.19": {
+      "name": "schannel",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/schannel/0.1.19/download",
+          "sha256": "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "schannel",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "schannel",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.1.19"
+      },
+      "license": "MIT"
+    },
+    "scopeguard 1.1.0": {
+      "name": "scopeguard",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/scopeguard/1.1.0/download",
+          "sha256": "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "scopeguard",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "scopeguard",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "security-framework 2.6.1": {
+      "name": "security-framework",
+      "version": "2.6.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/security-framework/2.6.1/download",
+          "sha256": "2dc14f172faf8a0194a3aded622712b0de276821addc574fa54fc0a1167e10dc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "security_framework",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "security_framework",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "OSX_10_9",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "core-foundation 0.9.3",
+              "target": "core_foundation"
+            },
+            {
+              "id": "core-foundation-sys 0.8.3",
+              "target": "core_foundation_sys"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "security-framework-sys 2.6.1",
+              "target": "security_framework_sys"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.6.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "security-framework-sys 2.6.1": {
+      "name": "security-framework-sys",
+      "version": "2.6.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/security-framework-sys/2.6.1/download",
+          "sha256": "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "security_framework_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "security_framework_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "OSX_10_9",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "core-foundation-sys 0.8.3",
+              "target": "core_foundation_sys"
+            },
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.6.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde 1.0.136": {
+      "name": "serde",
+      "version": "1.0.136",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde/1.0.136/download",
+          "sha256": "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "derive",
+          "serde_derive",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "serde_derive"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.136"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_derive 1.0.136": {
+      "name": "serde_derive",
+      "version": "1.0.136",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_derive/1.0.136/download",
+          "sha256": "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "serde_derive",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_derive",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "serde_derive 1.0.136",
+              "target": "build_script_build"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.0.136"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_json 1.0.79": {
+      "name": "serde_json",
+      "version": "1.0.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_json/1.0.79/download",
+          "sha256": "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_json",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_json",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "ryu 1.0.9",
+              "target": "ryu"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.79"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_regex 1.1.0": {
+      "name": "serde_regex",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_regex/1.1.0/download",
+          "sha256": "a8136f1a4ea815d7eac4101cfd0b16dc0cb5e1fe1b8609dfd728058656b7badf"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_regex",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_regex",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "regex 1.5.4",
+              "target": "regex"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "serde_urlencoded 0.7.1": {
+      "name": "serde_urlencoded",
+      "version": "0.7.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_urlencoded/0.7.1/download",
+          "sha256": "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_urlencoded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_urlencoded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "form_urlencoded 1.0.1",
+              "target": "form_urlencoded"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "ryu 1.0.9",
+              "target": "ryu"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "signal-hook 0.3.13": {
+      "name": "signal-hook",
+      "version": "0.3.13",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/signal-hook/0.3.13/download",
+          "sha256": "647c97df271007dcea485bb74ffdb57f2e683f1306c854f468a0c244badabf2d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "signal_hook",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "signal_hook",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "channel",
+          "iterator"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            },
+            {
+              "id": "signal-hook 0.3.13",
+              "target": "build_script_build"
+            },
+            {
+              "id": "signal-hook-registry 1.4.0",
+              "target": "signal_hook_registry"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.13"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "signal-hook-registry 1.4.0": {
+      "name": "signal-hook-registry",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/signal-hook-registry/1.4.0/download",
+          "sha256": "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "signal_hook_registry",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "signal_hook_registry",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "similar 2.1.0": {
+      "name": "similar",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/similar/2.1.0/download",
+          "sha256": "2e24979f63a11545f5f2c60141afe249d4f19f84581ea2138065e400941d83d3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "similar",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "similar",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "text"
+        ],
+        "edition": "2018",
+        "version": "2.1.0"
+      },
+      "license": "Apache-2.0"
+    },
+    "siphasher 0.3.10": {
+      "name": "siphasher",
+      "version": "0.3.10",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/siphasher/0.3.10/download",
+          "sha256": "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "siphasher",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "siphasher",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.10"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "slab 0.4.5": {
+      "name": "slab",
+      "version": "0.4.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/slab/0.4.5/download",
+          "sha256": "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "slab",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "slab",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.4.5"
+      },
+      "license": "MIT"
+    },
+    "sluice 0.5.5": {
+      "name": "sluice",
+      "version": "0.5.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/sluice/0.5.5/download",
+          "sha256": "6d7400c0eff44aa2fcb5e31a5f24ba9716ed90138769e4977a2ba6014ae63eb5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "sluice",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "sluice",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-channel 1.6.1",
+              "target": "async_channel"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-io 0.3.21",
+              "target": "futures_io"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.5.5"
+      },
+      "license": "MIT"
+    },
+    "smallvec 1.8.0": {
+      "name": "smallvec",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smallvec/1.8.0/download",
+          "sha256": "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smallvec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smallvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "socket2 0.4.4": {
+      "name": "socket2",
+      "version": "0.4.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/socket2/0.4.4/download",
+          "sha256": "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "socket2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "socket2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "all"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.4.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "string_cache 0.8.3": {
+      "name": "string_cache",
+      "version": "0.8.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/string_cache/0.8.3/download",
+          "sha256": "33994d0838dc2d152d17a62adf608a869b5e846b65b389af7f3dbc1de45c5b26"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "string_cache",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "string_cache",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "new_debug_unreachable 1.0.4",
+              "target": "debug_unreachable"
+            },
+            {
+              "id": "parking_lot 0.11.2",
+              "target": "parking_lot"
+            },
+            {
+              "id": "phf_shared 0.10.0",
+              "target": "phf_shared"
+            },
+            {
+              "id": "precomputed-hash 0.1.1",
+              "target": "precomputed_hash"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.8.3"
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "syn 1.0.86": {
+      "name": "syn",
+      "version": "1.0.86",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/syn/1.0.86/download",
+          "sha256": "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clone-impls",
+          "default",
+          "derive",
+          "extra-traits",
+          "full",
+          "parsing",
+          "printing",
+          "proc-macro",
+          "quote",
+          "visit",
+          "visit-mut"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.86"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "tempfile 3.3.0": {
+      "name": "tempfile",
+      "version": "3.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tempfile/3.3.0/download",
+          "sha256": "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tempfile",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tempfile",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "fastrand 1.7.0",
+              "target": "fastrand"
+            },
+            {
+              "id": "remove_dir_all 0.5.3",
+              "target": "remove_dir_all"
+            }
+          ],
+          "selects": {
+            "cfg(any(unix, target_os = \"wasi\"))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(target_os = \"redox\")": [
+              {
+                "id": "redox_syscall 0.2.11",
+                "target": "syscall"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "3.3.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "term 0.7.0": {
+      "name": "term",
+      "version": "0.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/term/0.7.0/download",
+          "sha256": "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "term",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "term",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "dirs-next 2.0.0",
+              "target": "dirs_next"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "rustversion 1.0.6",
+                "target": "rustversion"
+              }
+            ]
+          }
+        },
+        "version": "0.7.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "tiny-keccak 2.0.2": {
+      "name": "tiny-keccak",
+      "version": "2.0.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tiny-keccak/2.0.2/download",
+          "sha256": "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tiny_keccak",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tiny_keccak",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "sha3"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "crunchy 0.2.2",
+              "target": "crunchy"
+            },
+            {
+              "id": "tiny-keccak 2.0.2",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.0.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "CC0-1.0"
+    },
+    "tinyvec 1.5.1": {
+      "name": "tinyvec",
+      "version": "1.5.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tinyvec/1.5.1/download",
+          "sha256": "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tinyvec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tinyvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "tinyvec_macros"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "tinyvec_macros 0.1.0",
+              "target": "tinyvec_macros"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.5.1"
+      },
+      "license": "Zlib OR Apache-2.0 OR MIT"
+    },
+    "tinyvec_macros 0.1.0": {
+      "name": "tinyvec_macros",
+      "version": "0.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tinyvec_macros/0.1.0/download",
+          "sha256": "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tinyvec_macros",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tinyvec_macros",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": "MIT OR Apache-2.0 OR Zlib"
+    },
+    "tokio 1.17.0": {
+      "name": "tokio",
+      "version": "1.17.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio/1.17.0/download",
+          "sha256": "2af73ac49756f3f7c01172e34a23e5d0216f6c32333757c2c61feb2bbff5a5ee"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "bytes",
+          "default",
+          "io-util",
+          "libc",
+          "macros",
+          "memchr",
+          "mio",
+          "net",
+          "num_cpus",
+          "once_cell",
+          "rt",
+          "rt-multi-thread",
+          "signal",
+          "signal-hook-registry",
+          "socket2",
+          "sync",
+          "time",
+          "tokio-macros",
+          "winapi"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "mio 0.8.0",
+              "target": "mio"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              },
+              {
+                "id": "signal-hook-registry 1.4.0",
+                "target": "signal_hook_registry"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "tokio-macros 1.7.0",
+              "target": "tokio_macros"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.17.0"
+      },
+      "license": "MIT"
+    },
+    "tokio-macros 1.7.0": {
+      "name": "tokio-macros",
+      "version": "1.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-macros/1.7.0/download",
+          "sha256": "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "tokio_macros",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_macros",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.7.0"
+      },
+      "license": "MIT"
+    },
+    "tokio-native-tls 0.3.0": {
+      "name": "tokio-native-tls",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-native-tls/0.3.0/download",
+          "sha256": "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio_native_tls",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_native_tls",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "native-tls 0.2.8",
+              "target": "native_tls"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "tokio-util 0.6.9": {
+      "name": "tokio-util",
+      "version": "0.6.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-util/0.6.9/download",
+          "sha256": "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "codec",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-sink 0.3.21",
+              "target": "futures_sink"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.6.9"
+      },
+      "license": "MIT"
+    },
+    "tower-service 0.3.1": {
+      "name": "tower-service",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tower-service/0.3.1/download",
+          "sha256": "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tower_service",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tower_service",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "tracing 0.1.31": {
+      "name": "tracing",
+      "version": "0.1.31",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing/0.1.31/download",
+          "sha256": "f6c650a8ef0cd2dd93736f033d21cbd1224c5a967aa0c258d00fcf7dafef9b9f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "attributes",
+          "default",
+          "log",
+          "std",
+          "tracing-attributes"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tracing-core 0.1.22",
+              "target": "tracing_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "tracing-attributes 0.1.19",
+              "target": "tracing_attributes"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.1.31"
+      },
+      "license": "MIT"
+    },
+    "tracing-attributes 0.1.19": {
+      "name": "tracing-attributes",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-attributes/0.1.19/download",
+          "sha256": "8276d9a4a3a558d7b7ad5303ad50b53d58264641b82914b7ada36bd762e7a716"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "tracing_attributes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_attributes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT"
+    },
+    "tracing-core 0.1.22": {
+      "name": "tracing-core",
+      "version": "0.1.22",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-core/0.1.22/download",
+          "sha256": "03cfcb51380632a72d3111cb8d3447a8d908e577d31beeac006f836383d29a23"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "lazy_static",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.22"
+      },
+      "license": "MIT"
+    },
+    "tracing-futures 0.2.5": {
+      "name": "tracing-futures",
+      "version": "0.2.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-futures/0.2.5/download",
+          "sha256": "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing_futures",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_futures",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "pin-project",
+          "std",
+          "std-future"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "pin-project 1.0.10",
+              "target": "pin_project"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.5"
+      },
+      "license": "MIT"
+    },
+    "try-lock 0.2.3": {
+      "name": "try-lock",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/try-lock/0.2.3/download",
+          "sha256": "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "try_lock",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "try_lock",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.3"
+      },
+      "license": "MIT"
+    },
+    "typenum 1.15.0": {
+      "name": "typenum",
+      "version": "1.15.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/typenum/1.15.0/download",
+          "sha256": "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "typenum",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_main",
+            "crate_root": "build/main.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "typenum",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "typenum 1.15.0",
+              "target": "build_script_main"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.15.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "unicode-bidi 0.3.7": {
+      "name": "unicode-bidi",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-bidi/0.3.7/download",
+          "sha256": "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_bidi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_bidi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "license": "MIT / Apache-2.0"
+    },
+    "unicode-normalization 0.1.19": {
+      "name": "unicode-normalization",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-normalization/0.1.19/download",
+          "sha256": "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_normalization",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_normalization",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "tinyvec 1.5.1",
+              "target": "tinyvec"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "unicode-xid 0.2.2": {
+      "name": "unicode-xid",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+          "sha256": "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_xid",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_xid",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "url 2.2.2": {
+      "name": "url",
+      "version": "2.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/url/2.2.2/download",
+          "sha256": "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "url",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "url",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "form_urlencoded 1.0.1",
+              "target": "form_urlencoded"
+            },
+            {
+              "id": "idna 0.2.3",
+              "target": "idna"
+            },
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.2.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "value-bag 1.0.0-alpha.8": {
+      "name": "value-bag",
+      "version": "1.0.0-alpha.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/value-bag/1.0.0-alpha.8/download",
+          "sha256": "79923f7731dc61ebfba3633098bf3ac533bbd35ccd8c57e7088d9a5eebe0263f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "value_bag",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "value_bag",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "value-bag 1.0.0-alpha.8",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "ctor 0.1.21",
+              "target": "ctor"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.0-alpha.8"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "version_check 0.9.4",
+              "target": "version_check",
+              "alias": "rustc"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "vcpkg 0.2.15": {
+      "name": "vcpkg",
+      "version": "0.2.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/vcpkg/0.2.15/download",
+          "sha256": "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "vcpkg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "vcpkg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.15"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "version_check 0.9.4": {
+      "name": "version_check",
+      "version": "0.9.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/version_check/0.9.4/download",
+          "sha256": "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "version_check",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "version_check",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.9.4"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "waker-fn 1.1.0": {
+      "name": "waker-fn",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/waker-fn/1.1.0/download",
+          "sha256": "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "waker_fn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "waker_fn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "want 0.3.0": {
+      "name": "want",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/want/0.3.0/download",
+          "sha256": "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "want",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "want",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "try-lock 0.2.3",
+              "target": "try_lock"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "wasi 0.10.2+wasi-snapshot-preview1": {
+      "name": "wasi",
+      "version": "0.10.2+wasi-snapshot-preview1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download",
+          "sha256": "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.10.2+wasi-snapshot-preview1"
+      },
+      "license": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+    },
+    "wasm-bindgen 0.2.79": {
+      "name": "wasm-bindgen",
+      "version": "0.2.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen/0.2.79/download",
+          "sha256": "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasm_bindgen",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "spans",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "wasm-bindgen 0.2.79",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "wasm-bindgen-macro 0.2.79",
+              "target": "wasm_bindgen_macro"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.2.79"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasm-bindgen-backend 0.2.79": {
+      "name": "wasm-bindgen-backend",
+      "version": "0.2.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen-backend/0.2.79/download",
+          "sha256": "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasm_bindgen_backend",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen_backend",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "spans"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bumpalo 3.9.1",
+              "target": "bumpalo"
+            },
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            },
+            {
+              "id": "wasm-bindgen-shared 0.2.79",
+              "target": "wasm_bindgen_shared"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.79"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasm-bindgen-futures 0.4.29": {
+      "name": "wasm-bindgen-futures",
+      "version": "0.4.29",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen-futures/0.4.29/download",
+          "sha256": "2eb6ec270a31b1d3c7e266b999739109abce8b6c87e4b31fcfcd788b65267395"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasm_bindgen_futures",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen_futures",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "js-sys 0.3.56",
+              "target": "js_sys"
+            },
+            {
+              "id": "wasm-bindgen 0.2.79",
+              "target": "wasm_bindgen"
+            }
+          ],
+          "selects": {
+            "cfg(target_feature = \"atomics\")": [
+              {
+                "id": "web-sys 0.3.56",
+                "target": "web_sys"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.4.29"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasm-bindgen-macro 0.2.79": {
+      "name": "wasm-bindgen-macro",
+      "version": "0.2.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen-macro/0.2.79/download",
+          "sha256": "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "wasm_bindgen_macro",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen_macro",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "spans"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "wasm-bindgen-macro-support 0.2.79",
+              "target": "wasm_bindgen_macro_support"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.79"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasm-bindgen-macro-support 0.2.79": {
+      "name": "wasm-bindgen-macro-support",
+      "version": "0.2.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen-macro-support/0.2.79/download",
+          "sha256": "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasm_bindgen_macro_support",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen_macro_support",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "spans"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            },
+            {
+              "id": "wasm-bindgen-backend 0.2.79",
+              "target": "wasm_bindgen_backend"
+            },
+            {
+              "id": "wasm-bindgen-shared 0.2.79",
+              "target": "wasm_bindgen_shared"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.79"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wasm-bindgen-shared 0.2.79": {
+      "name": "wasm-bindgen-shared",
+      "version": "0.2.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wasm-bindgen-shared/0.2.79/download",
+          "sha256": "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wasm_bindgen_shared",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wasm_bindgen_shared",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "wasm-bindgen-shared 0.2.79",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.79"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "links": "wasm_bindgen"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "web-sys 0.3.56": {
+      "name": "web-sys",
+      "version": "0.3.56",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/web-sys/0.3.56/download",
+          "sha256": "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "web_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "web_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "Blob",
+          "BlobPropertyBag",
+          "Event",
+          "EventTarget",
+          "File",
+          "FormData",
+          "Headers",
+          "MessageEvent",
+          "Request",
+          "RequestCredentials",
+          "RequestInit",
+          "RequestMode",
+          "Response",
+          "ServiceWorkerGlobalScope",
+          "Window",
+          "Worker",
+          "WorkerGlobalScope"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "js-sys 0.3.56",
+              "target": "js_sys"
+            },
+            {
+              "id": "wasm-bindgen 0.2.79",
+              "target": "wasm_bindgen"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.56"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "wepoll-ffi 0.1.2": {
+      "name": "wepoll-ffi",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/wepoll-ffi/0.1.2/download",
+          "sha256": "d743fdedc5c64377b5fc2bc036b01c7fd642205a0d96356034ae3404d49eb7fb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "wepoll_ffi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "wepoll_ffi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "null-overlapped-wakeups-patch"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "wepoll-ffi 0.1.2",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**",
+          "vendor/**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cc 1.0.73",
+              "target": "cc"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "MIT OR Apache-2.0 OR BSD-2-Clause"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "cfg",
+          "consoleapi",
+          "errhandlingapi",
+          "evntrace",
+          "fileapi",
+          "handleapi",
+          "impl-debug",
+          "impl-default",
+          "in6addr",
+          "inaddr",
+          "ioapiset",
+          "knownfolders",
+          "libloaderapi",
+          "lmcons",
+          "minschannel",
+          "minwinbase",
+          "minwindef",
+          "mswsock",
+          "namedpipeapi",
+          "ntdef",
+          "ntsecapi",
+          "ntstatus",
+          "objbase",
+          "processenv",
+          "schannel",
+          "securitybaseapi",
+          "shlobj",
+          "sspi",
+          "std",
+          "synchapi",
+          "sysinfoapi",
+          "timezoneapi",
+          "winbase",
+          "wincon",
+          "wincrypt",
+          "windef",
+          "winerror",
+          "winioctl",
+          "winnt",
+          "winreg",
+          "winsock2",
+          "ws2def",
+          "ws2ipdef",
+          "ws2tcpip"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winreg 0.7.0": {
+      "name": "winreg",
+      "version": "0.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winreg/0.7.0/download",
+          "sha256": "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winreg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winreg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.7.0"
+      },
+      "license": "MIT"
+    }
+  },
+  "binary_crates": [
+    "cc 1.0.73",
+    "httpmock 0.6.6",
+    "lalrpop 0.19.7"
+  ],
+  "workspace_members": {
+    "direct-cargo-bazel-deps 0.0.1": "",
+    "pkg_a 0.1.0": "multi_package/pkg_a",
+    "pkg_b 0.1.0": "multi_package/sub_pkgs/pkg_b",
+    "pkg_c 0.1.0": "multi_package/sub_pkgs/pkg_c"
+  },
+  "conditions": {
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(all(unix, not(target_os = \"macos\")))": [
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(any(target_os = \"macos\", target_os = \"ios\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "i686-apple-darwin",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios"
+    ],
+    "cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(any(unix, target_os = \"wasi\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(any(target_os = \"windows\", target_os = \"macos\", target_os = \"ios\")))": [
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(target_arch = \"wasm32\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-pc-windows-msvc",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(target_os = \"unknown\"))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-pc-windows-msvc",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(not(windows))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(target_arch = \"wasm32\")": [
+      "wasm32-unknown-unknown",
+      "wasm32-wasi"
+    ],
+    "cfg(target_env = \"msvc\")": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "cfg(target_feature = \"atomics\")": [],
+    "cfg(target_os = \"hermit\")": [],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"wasi\")": [
+      "wasm32-wasi"
+    ],
+    "cfg(target_os = \"windows\")": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": []
+  }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/BUILD.bazel
new file mode 100644
index 0000000..ff809ad
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/BUILD.bazel
@@ -0,0 +1,32 @@
+load("@m_pkgs//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "pkg_a",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    # TODO: There's an issue building OpenSSL on Windows in GitHub CI so for
+    # now all targets that depend on it are disabled
+    target_compatible_with = select({
+        "@platforms//os:linux": [],
+        "@platforms//os:macos": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    aliases = aliases(),
+    crate = ":pkg_a",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    # TODO: There's an issue building OpenSSL on Windows in GitHub CI so for
+    # now all targets that depend on it are disabled
+    target_compatible_with = select({
+        "@platforms//os:linux": [],
+        "@platforms//os:macos": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.lock b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.lock
new file mode 100644
index 0000000..9360870
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.lock
@@ -0,0 +1,1864 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7"
+
+[[package]]
+name = "ascii-canvas"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+dependencies = [
+ "term",
+]
+
+[[package]]
+name = "assert-json-diff"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f1c3703dd33532d7f0ca049168930e9099ecac238e23cf932f3a69c42f06da"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "async-channel"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2114d64672151c0c5eaa5e131ec84a74f06e1e559830dabba01ca30605d66319"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "871f9bb5e0a22eeb7e8cf16641feb87c9dc67032ccf8ff49e772eb9941d3a965"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "once_cell",
+ "slab",
+]
+
+[[package]]
+name = "async-global-executor"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9586ec52317f36de58453159d48351bc244bc24ced3effc1fce22f3d48664af6"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-io",
+ "async-mutex",
+ "blocking",
+ "futures-lite",
+ "num_cpus",
+ "once_cell",
+]
+
+[[package]]
+name = "async-io"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a811e6a479f2439f0c04038796b5cfb3d2ad56c230e0f2d3f7b04d68cfee607b"
+dependencies = [
+ "concurrent-queue",
+ "futures-lite",
+ "libc",
+ "log",
+ "once_cell",
+ "parking",
+ "polling",
+ "slab",
+ "socket2",
+ "waker-fn",
+ "winapi",
+]
+
+[[package]]
+name = "async-lock"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6a8ea61bf9947a1007c5cada31e647dbc77b103c679858150003ba697ea798b"
+dependencies = [
+ "event-listener",
+]
+
+[[package]]
+name = "async-mutex"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479db852db25d9dbf6204e6cb6253698f175c15726470f78af0d918e99d6156e"
+dependencies = [
+ "event-listener",
+]
+
+[[package]]
+name = "async-object-pool"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aeb901c30ebc2fc4ab46395bbfbdba9542c16559d853645d75190c3056caf3bc"
+dependencies = [
+ "async-std",
+]
+
+[[package]]
+name = "async-process"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b21b63ab5a0db0369deb913540af2892750e42d949faacc7a61495ac418a1692"
+dependencies = [
+ "async-io",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "libc",
+ "once_cell",
+ "signal-hook",
+ "winapi",
+]
+
+[[package]]
+name = "async-std"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8056f1455169ab86dd47b47391e4ab0cbd25410a70e9fe675544f49bafaf952"
+dependencies = [
+ "async-channel",
+ "async-global-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "crossbeam-utils",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-lite",
+ "gloo-timers",
+ "kv-log-macro",
+ "log",
+ "memchr",
+ "num_cpus",
+ "once_cell",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "async-task"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91831deabf0d6d7ec49552e489aed63b7456a7a3c46cff62adad428110b0af0"
+
+[[package]]
+name = "async-trait"
+version = "0.1.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44318e776df68115a881de9a8fd1b9e53368d7a4a5ce4cc48517da3393233a5e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "065374052e7df7ee4047b1160cca5e1467a12351a40b3da123c870ba0b8eda2a"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "base64"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
+
+[[package]]
+name = "basic-cookies"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb53b6b315f924c7f113b162e53b3901c05fc9966baf84d201dfcc7432a4bb38"
+dependencies = [
+ "lalrpop",
+ "lalrpop-util",
+ "regex",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "blocking"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e170dbede1f740736619b776d7251cb1b9095c435c34d8ca9f57fcd2f335e9"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "atomic-waker",
+ "fastrand",
+ "futures-lite",
+ "once_cell",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cache-padded"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "631ae5198c9be5e753e5cc215e1bd73c2b466a3565173db433f52bb9d3e66dba"
+
+[[package]]
+name = "castaway"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed247d1586918e46f2bbe0f13b06498db8dab5a8c1093f156652e9f2e0a73fc3"
+
+[[package]]
+name = "cc"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "concurrent-queue"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ed07550be01594c6026cff2a1d7fe9c8f683caa798e12b68694ac9e88286a3"
+dependencies = [
+ "cache-padded",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6888e10551bb93e424d8df1d07f1a8b4fceb0001a3a4b048bfc47554946f47b3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+dependencies = [
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "ctor"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "curl"
+version = "0.4.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877cc2f9b8367e32b6dabb9d581557e651cb3aa693a37f8679091bbf42687d5d"
+dependencies = [
+ "curl-sys",
+ "libc",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "socket2",
+ "winapi",
+]
+
+[[package]]
+name = "curl-sys"
+version = "0.4.50+curl-7.79.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4856b76919dd599f31236bb18db5f5bd36e2ce131e64f857ca5c259665b76171"
+dependencies = [
+ "cc",
+ "libc",
+ "libnghttp2-sys",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+ "winapi",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+
+[[package]]
+name = "difference"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "ena"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7402b94a93c24e742487327a7cd839dc9d36fec9de9fb25b09f2dae459f36c3"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a74ea89a0a1b98f6332de42c95baff457ada66d1cb4030f9ff151b2041a1c746"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7531096570974c3a9dcf9e4b8e1cede1ec26cf5046219fb3b9d897503b9be59"
+
+[[package]]
+name = "fastrand"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b394ed3d285a429378d3b384b9eb1285267e7df4b166df24b7a6939a04dc392e"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+dependencies = [
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5da6ba8c3bb3c165d3c7319fc1cc8304facf1fb8db99c5de877183c08a273888"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d1c26957f23603395cd326b0ffe64124b818f4449552f960d815cfba83a53d"
+
+[[package]]
+name = "futures-io"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "522de2a0fe3e380f1bc577ba0474108faf3f6b18321dbf60b3b9c39a75073377"
+
+[[package]]
+name = "futures-lite"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e4a4b95cea4b4ccbcf1c5675ca7c4ee4e9e75eb79944d07defde18068f79bb"
+dependencies = [
+ "autocfg",
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36ea153c13024fe480590b3e3d4cad89a0cfacecc24577b68f86c6ced9c2bc11"
+
+[[package]]
+name = "futures-task"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d3d00f4eddb73e498a54394f228cd55853bdf059259e8e7bc6e69d408892e99"
+
+[[package]]
+name = "futures-util"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36568465210a3a6ee45e1f165136d68671471a501e632e9a98d96872222b5481"
+dependencies = [
+ "autocfg",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "proc-macro-hack",
+ "proc-macro-nested",
+ "slab",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "gloo-timers"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47204a46aaff920a1ea58b11d03dec6f704287d27561724a4631e450654a891f"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "h2"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fd819562fcebdac5afc5c113c3ec36f902840b70fd4fc458799c8ce4607ae55"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "http"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1323096b05d41827dadeaee54c9981958c0f94e670bc94ed80037d1a7b8b186b"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ff4f84919677303da5f147645dbea6b1881f368d03ac84e1dc09031ebd7b2c6"
+dependencies = [
+ "bytes",
+ "http",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acd94fdbe1d4ff688b67b04eee2e17bd50995534a61539e45adfefb45e5e5503"
+
+[[package]]
+name = "httpdate"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6456b8a6c8f33fee7d958fcd1b60d55b11940a79e63ae87013e6d22e26034440"
+
+[[package]]
+name = "httpmock"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "218c2c3dabf4497c87d042b43984a5fd03bcd8a6adb0056ade7df20f88df225a"
+dependencies = [
+ "assert-json-diff",
+ "async-object-pool",
+ "async-trait",
+ "base64",
+ "basic-cookies",
+ "crossbeam-utils",
+ "difference",
+ "form_urlencoded",
+ "futures-util",
+ "hyper",
+ "isahc",
+ "lazy_static",
+ "levenshtein",
+ "log",
+ "qstring",
+ "regex",
+ "serde",
+ "serde_json",
+ "serde_regex",
+ "tokio",
+]
+
+[[package]]
+name = "hyper"
+version = "0.14.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b91bb1f221b6ea1f1e4371216b70f40748774c2fb5971b450c07773fb92d26b"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+dependencies = [
+ "bytes",
+ "hyper",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+]
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9"
+
+[[package]]
+name = "isahc"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ef5402b1791c9fc479ef9871601a2f10e4cc0f14414a5c9c6e043fb51e5a56"
+dependencies = [
+ "async-channel",
+ "castaway",
+ "crossbeam-utils",
+ "curl",
+ "curl-sys",
+ "encoding_rs",
+ "event-listener",
+ "futures-lite",
+ "http",
+ "log",
+ "mime",
+ "once_cell",
+ "polling",
+ "slab",
+ "sluice",
+ "tracing",
+ "tracing-futures",
+ "url",
+ "waker-fn",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "js-sys"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cc9ffccd38c451a86bf13657df244e9c3f37493cce8e5e21e940963777acc84"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kv-log-macro"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "lalrpop"
+version = "0.19.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15174f1c529af5bf1283c3bc0058266b483a67156f79589fab2a25e23cf8988"
+dependencies = [
+ "ascii-canvas",
+ "atty",
+ "bit-set",
+ "diff",
+ "ena",
+ "itertools",
+ "lalrpop-util",
+ "petgraph",
+ "pico-args",
+ "regex",
+ "regex-syntax",
+ "string_cache",
+ "term",
+ "tiny-keccak",
+ "unicode-xid",
+]
+
+[[package]]
+name = "lalrpop-util"
+version = "0.19.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e58cce361efcc90ba8a0a5f982c741ff86b603495bb15a998412e957dcd278"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "levenshtein"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
+
+[[package]]
+name = "libc"
+version = "0.2.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+
+[[package]]
+name = "libnghttp2-sys"
+version = "0.1.7+1.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57ed28aba195b38d5ff02b9170cbff627e336a20925e43b4945390401c5dc93f"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+ "value-bag",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "mime"
+version = "0.3.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+
+[[package]]
+name = "mio"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"
+dependencies = [
+ "libc",
+ "log",
+ "miow",
+ "ntapi",
+ "winapi",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
+
+[[package]]
+name = "ntapi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
+
+[[package]]
+name = "openssl"
+version = "0.10.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6517987b3f8226b5da3661dad65ff7f300cc59fb5ea8333ca191fc65fde3edf"
+dependencies = [
+ "autocfg",
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "parking"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "petgraph"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "467d164a6de56270bd7c4d070df81d07beace25012d5103ced4e9ff08d6afdb7"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pico-args"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
+
+[[package]]
+name = "pin-project"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "576bc800220cc65dac09e99e97b08b358cfab6e17078de8dc5fee223bd2d0c08"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e8fe8163d14ce7f0cdac2e040116f22eac817edabff0be91e8aff7e9accf389"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
+
+[[package]]
+name = "pkg_a"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "httpmock",
+ "reqwest",
+]
+
+[[package]]
+name = "polling"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92341d779fa34ea8437ef4d82d440d5e1ce3f3ff7f824aa64424cd481f9a1f25"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "log",
+ "wepoll-ffi",
+ "winapi",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba"
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
+
+[[package]]
+name = "proc-macro-nested"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "qstring"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d464fae65fff2680baf48019211ce37aaec0c78e9264c84a3e484717f965104e"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+dependencies = [
+ "getrandom",
+ "redox_syscall",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66d2927ca2f685faf0fc620ac4834690d29e7abb153add10f5812eef20b5e280"
+dependencies = [
+ "base64",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-tls",
+ "ipnet",
+ "js-sys",
+ "lazy_static",
+ "log",
+ "mime",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "tokio",
+ "tokio-native-tls",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winreg",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61b3909d758bb75c79f23d4736fac9433868679d3ad2ea7a61e3c25cfda9a088"
+
+[[package]]
+name = "ryu"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+
+[[package]]
+name = "schannel"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+dependencies = [
+ "lazy_static",
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "security-framework"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525bc1abfda2e1998d152c45cf13e696f76d0a4972310b22fac1658b05df7c87"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9dd14d83160b528b7bfd66439110573efcfbe281b17fc2ca9f39f550d619c7e"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e466864e431129c7e0d3476b92f20458e5879919a0596c6472738d9fa2d342f8"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_regex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8136f1a4ea815d7eac4101cfd0b16dc0cb5e1fe1b8609dfd728058656b7badf"
+dependencies = [
+ "regex",
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c98891d737e271a2954825ef19e46bd16bdb98e2746f2eec4f7a4ef7946efd1"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "533494a8f9b724d33625ab53c6c4800f7cc445895924a8ef649222dcb76e938b"
+
+[[package]]
+name = "slab"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
+
+[[package]]
+name = "sluice"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d7400c0eff44aa2fcb5e31a5f24ba9716ed90138769e4977a2ba6014ae63eb5"
+dependencies = [
+ "async-channel",
+ "futures-core",
+ "futures-io",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ecab6c735a6bb4139c0caafd0cc3635748bbb3acf4550e8138122099251f309"
+
+[[package]]
+name = "socket2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "string_cache"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "923f0f39b6267d37d23ce71ae7235602134b250ace715dd2c90421998ddac0c6"
+dependencies = [
+ "lazy_static",
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "term"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+dependencies = [
+ "dirs-next",
+ "rustversion",
+ "winapi",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "tokio"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588b2d10a336da58d877567cd8fb8a14b463e2104910f8132cd054b4b96e29ee"
+dependencies = [
+ "autocfg",
+ "bytes",
+ "libc",
+ "memchr",
+ "mio",
+ "num_cpus",
+ "once_cell",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "tokio-macros",
+ "winapi",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "114383b041aa6212c579467afa0075fbbdd0718de036100bc0ba7961d8cb9095"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "log",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tower-service"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+
+[[package]]
+name = "tracing"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "375a639232caf30edfc78e8d89b2d4c375515393e7af7e16f01cd96917fb2105"
+dependencies = [
+ "cfg-if",
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f480b8f81512e825f337ad51e94c1eb5d3bbdf2b363dcd01e2b19a9ffe3f8e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f4ed65637b8390770814083d20756f87bfa2c21bf2f110babdc5438351746e4"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "tracing-futures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+dependencies = [
+ "pin-project",
+ "tracing",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "url"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "value-bag"
+version = "1.0.0-alpha.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79923f7731dc61ebfba3633098bf3ac533bbd35ccd8c57e7088d9a5eebe0263f"
+dependencies = [
+ "ctor",
+ "version_check",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
+[[package]]
+name = "want"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+dependencies = [
+ "log",
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d7523cb1f2a4c96c1317ca690031b714a51cc14e05f712446691f413f5d39"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc"
+
+[[package]]
+name = "web-sys"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38eb105f1c59d9eaa6b5cdc92b859d85b926e82cb2e0945cd0c9259faa6fe9fb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wepoll-ffi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d743fdedc5c64377b5fc2bc036b01c7fd642205a0d96356034ae3404d49eb7fb"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "winreg"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
+dependencies = [
+ "winapi",
+]
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.toml b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.toml
new file mode 100644
index 0000000..2005a59
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "pkg_a"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.44"
+reqwest = { version = "0.11.4", features = ["blocking", "json"] }
+
+[dev-dependencies]
+httpmock = "0.6.2"
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/src/lib.rs b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/src/lib.rs
new file mode 100644
index 0000000..790c3a5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/pkg_a/src/lib.rs
@@ -0,0 +1,40 @@
+use anyhow::{Context, Result};
+
+pub fn request(url: &str) -> Result<reqwest::blocking::Response> {
+    reqwest::blocking::get(url).context("Failed to make request")
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use httpmock::prelude::*;
+
+    #[test]
+    fn test_request() {
+        // Start a lightweight mock server.
+        let server = MockServer::start();
+
+        // Create a mock on the server.
+        let hello_mock = server.mock(|when, then| {
+            when.method(GET)
+                .path("/translate")
+                .query_param("word", "hello");
+            then.status(200)
+                .header("content-type", "text/html; charset=UTF-8")
+                .body("Hallo");
+        });
+
+        // Send an HTTP request to the mock server. This simulates your code.
+        let response = request(&server.url("/translate?word=hello")).unwrap();
+
+        // Ensure the specified mock was called exactly one time (or fail with a detailed error description).
+        hello_mock.assert();
+
+        // Ensure the mock server did respond as specified.
+        assert_eq!(response.status(), 200);
+
+        // Ensure the body contains the results we expect
+        assert_eq!(response.text().unwrap(), "Hallo")
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/BUILD.bazel
new file mode 100644
index 0000000..8ede88d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/BUILD.bazel
@@ -0,0 +1,32 @@
+load("@m_pkgs//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "pkg_b",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    # TODO: There's an issue building OpenSSL on Windows in GitHub CI so for
+    # now all targets that depend on it are disabled
+    target_compatible_with = select({
+        "@platforms//os:linux": [],
+        "@platforms//os:macos": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    aliases = aliases(),
+    crate = ":pkg_b",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    # TODO: There's an issue building OpenSSL on Windows in GitHub CI so for
+    # now all targets that depend on it are disabled
+    target_compatible_with = select({
+        "@platforms//os:linux": [],
+        "@platforms//os:macos": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.lock b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.lock
new file mode 100644
index 0000000..78dff50
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.lock
@@ -0,0 +1,100 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cc"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "libc"
+version = "0.2.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+
+[[package]]
+name = "once_cell"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
+
+[[package]]
+name = "openssl"
+version = "0.10.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6517987b3f8226b5da3661dad65ff7f300cc59fb5ea8333ca191fc65fde3edf"
+dependencies = [
+ "autocfg",
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
+
+[[package]]
+name = "pkg_b"
+version = "0.1.0"
+dependencies = [
+ "openssl",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.toml b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.toml
new file mode 100644
index 0000000..fbc4c51
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "pkg_b"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+openssl = "0.10.36"
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/src/lib.rs b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/src/lib.rs
new file mode 100644
index 0000000..3610031
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_b/src/lib.rs
@@ -0,0 +1,13 @@
+pub fn openssl_version() -> i64 {
+    openssl::version::number()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_opnessl_version() {
+        assert_ne!(openssl_version(), 0)
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/BUILD.bazel
new file mode 100644
index 0000000..37ca0b8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@m_pkgs//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "pkg_b",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    aliases = aliases(),
+    crate = ":pkg_b",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.lock b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.lock
new file mode 100644
index 0000000..e684bd3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.lock
@@ -0,0 +1,74 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "block-buffer"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "hex-literal"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21e4590e13640f19f249fe3e4eca5113bc4289f2497710378190e7f4bd96f45b"
+
+[[package]]
+name = "md-5"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5a279bb9607f9f53c22d496eade00d138d1bdcccd07d74650387cf94942a15"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+
+[[package]]
+name = "pkg_c"
+version = "0.1.0"
+dependencies = [
+ "hex-literal",
+ "md-5",
+]
+
+[[package]]
+name = "typenum"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.toml b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.toml
new file mode 100644
index 0000000..1b9a0b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "pkg_c"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+md-5 = "0.9.1"
+
+[dev-dependencies]
+hex-literal = "0.3.3"
diff --git a/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/src/lib.rs b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/src/lib.rs
new file mode 100644
index 0000000..092d273
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/multi_package/sub_pkgs/pkg_c/src/lib.rs
@@ -0,0 +1,29 @@
+use md5::{Digest, Md5};
+
+pub fn hash(bytes: impl AsRef<[u8]>) -> Vec<u8> {
+    // create a Md5 hasher instance
+    let mut hasher = Md5::new();
+
+    // process input message
+    hasher.update(bytes);
+
+    // acquire hash digest in the form of GenericArray,
+    // which in this case is equivalent to [u8; 16]
+    let result = hasher.finalize();
+    result[..].into()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use hex_literal::hex;
+
+    #[test]
+    fn test_hash() {
+        assert_eq!(
+            hash(b"hello world")[..],
+            hex!("5eb63bbbe01eeed093cb22bb8f5acdc3")
+        )
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/.bazelrc b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/.bazelrc
new file mode 100644
index 0000000..d63c809
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/.bazelrc
@@ -0,0 +1,13 @@
+# A config file containing Bazel settings
+
+# Enable rustfmt
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+
+# Enable clippy
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+
+# This import should always be last to allow users to override
+# settings for local development.
+try-import %workspace%/user.bazelrc
diff --git a/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/BUILD.bazel
new file mode 100644
index 0000000..2691eb2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/BUILD.bazel
@@ -0,0 +1,25 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
+
+rust_binary(
+    name = "no_cargo_manifests",
+    srcs = glob(["**/*.rs"]),
+    edition = "2018",
+    deps = [
+        "@no_cargo//:axum",
+        "@no_cargo//:hyper",
+        "@no_cargo//:mime",
+        "@no_cargo//:serde_json",
+        "@no_cargo//:tokio",
+        "@no_cargo//:tower",
+        "@no_cargo//:tower-http",
+        "@no_cargo//:tracing",
+        "@no_cargo//:tracing-subscriber",
+    ],
+)
+
+rust_test(
+    name = "unit_test",
+    srcs = glob(["**/*.rs"]),
+    crate = ":no_cargo_manifests",
+    edition = "2018",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/Cargo.Bazel.lock b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/Cargo.Bazel.lock
new file mode 100644
index 0000000..6164f28
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/Cargo.Bazel.lock
@@ -0,0 +1,5006 @@
+{
+  "checksum": "5c8bd4f7527784376a1667a00ecf8f9ddd398a2a3ccefee5201b383f56d2c99b",
+  "crates": {
+    "ansi_term 0.12.1": {
+      "name": "ansi_term",
+      "version": "0.12.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ansi_term/0.12.1/download",
+          "sha256": "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ansi_term",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ansi_term",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(target_os = \"windows\")": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.12.1"
+      },
+      "license": "MIT"
+    },
+    "async-trait 0.1.52": {
+      "name": "async-trait",
+      "version": "0.1.52",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/async-trait/0.1.52/download",
+          "sha256": "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "async_trait",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "async_trait",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "async-trait 0.1.52",
+              "target": "build_script_build"
+            },
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.52"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "autocfg 1.1.0": {
+      "name": "autocfg",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/autocfg/1.1.0/download",
+          "sha256": "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "autocfg",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "autocfg",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "axum 0.4.8": {
+      "name": "axum",
+      "version": "0.4.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/axum/0.4.8/download",
+          "sha256": "c9f346c92c1e9a71d14fe4aaf7c2a5d9932cc4e5e48d8fb6641524416eb79ddd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "axum",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "axum",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**",
+          "**/*.md"
+        ],
+        "crate_features": [
+          "default",
+          "http1",
+          "json",
+          "serde_json",
+          "tower-log"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "axum-core 0.1.2",
+              "target": "axum_core"
+            },
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "http-body 0.4.4",
+              "target": "http_body"
+            },
+            {
+              "id": "hyper 0.14.17",
+              "target": "hyper"
+            },
+            {
+              "id": "matchit 0.4.6",
+              "target": "matchit"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "mime 0.3.16",
+              "target": "mime"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "serde_urlencoded 0.7.1",
+              "target": "serde_urlencoded"
+            },
+            {
+              "id": "sync_wrapper 0.1.1",
+              "target": "sync_wrapper"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tower 0.4.12",
+              "target": "tower"
+            },
+            {
+              "id": "tower-http 0.2.4",
+              "target": "tower_http"
+            },
+            {
+              "id": "tower-layer 0.3.1",
+              "target": "tower_layer"
+            },
+            {
+              "id": "tower-service 0.3.1",
+              "target": "tower_service"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "async-trait 0.1.52",
+              "target": "async_trait"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.4.8"
+      },
+      "license": "MIT"
+    },
+    "axum-core 0.1.2": {
+      "name": "axum-core",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/axum-core/0.1.2/download",
+          "sha256": "6dbcda393bef9c87572779cb8ef916f12d77750b27535dd6819fa86591627a51"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "axum_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "axum_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "http-body 0.4.4",
+              "target": "http_body"
+            },
+            {
+              "id": "mime 0.3.16",
+              "target": "mime"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "async-trait 0.1.52",
+              "target": "async_trait"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.1.2"
+      },
+      "license": "MIT"
+    },
+    "bitflags 1.3.2": {
+      "name": "bitflags",
+      "version": "1.3.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+          "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bitflags",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bitflags",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "1.3.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "bytes 1.1.0": {
+      "name": "bytes",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/bytes/1.1.0/download",
+          "sha256": "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "bytes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "bytes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.1.0"
+      },
+      "license": "MIT"
+    },
+    "cfg-if 1.0.0": {
+      "name": "cfg-if",
+      "version": "1.0.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+          "sha256": "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "cfg_if",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "cfg_if",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "direct-cargo-bazel-deps 0.0.1": {
+      "name": "direct-cargo-bazel-deps",
+      "version": "0.0.1",
+      "repository": null,
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "direct_cargo_bazel_deps",
+            "crate_root": ".direct_cargo_bazel_deps.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "direct_cargo_bazel_deps",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "axum 0.4.8",
+              "target": "axum"
+            },
+            {
+              "id": "hyper 0.14.17",
+              "target": "hyper"
+            },
+            {
+              "id": "mime 0.3.16",
+              "target": "mime"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "serde_json"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tower 0.4.12",
+              "target": "tower"
+            },
+            {
+              "id": "tower-http 0.2.4",
+              "target": "tower_http"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            },
+            {
+              "id": "tracing-subscriber 0.3.9",
+              "target": "tracing_subscriber"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.0.1"
+      },
+      "license": null
+    },
+    "fnv 1.0.7": {
+      "name": "fnv",
+      "version": "1.0.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/fnv/1.0.7/download",
+          "sha256": "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "fnv",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "fnv",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2015",
+        "version": "1.0.7"
+      },
+      "license": "Apache-2.0 / MIT"
+    },
+    "form_urlencoded 1.0.1": {
+      "name": "form_urlencoded",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download",
+          "sha256": "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "form_urlencoded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "form_urlencoded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "matches 0.1.9",
+              "target": "matches"
+            },
+            {
+              "id": "percent-encoding 2.1.0",
+              "target": "percent_encoding"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "futures-channel 0.3.21": {
+      "name": "futures-channel",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-channel/0.3.21/download",
+          "sha256": "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_channel",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_channel",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-channel 0.3.21",
+              "target": "build_script_build"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-core 0.3.21": {
+      "name": "futures-core",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-core/0.3.21/download",
+          "sha256": "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-core 0.3.21",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-sink 0.3.21": {
+      "name": "futures-sink",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-sink/0.3.21/download",
+          "sha256": "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_sink",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_sink",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-task 0.3.21": {
+      "name": "futures-task",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-task/0.3.21/download",
+          "sha256": "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_task",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_task",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-task 0.3.21",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "futures-util 0.3.21": {
+      "name": "futures-util",
+      "version": "0.3.21",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/futures-util/0.3.21/download",
+          "sha256": "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "futures_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "futures_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-task 0.3.21",
+              "target": "futures_task"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "build_script_build"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "pin-utils 0.1.0",
+              "target": "pin_utils"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.21"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "h2 0.3.11": {
+      "name": "h2",
+      "version": "0.3.11",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/h2/0.3.11/download",
+          "sha256": "d9f1f717ddc7b2ba36df7e871fd88db79326551d3d6f1fc406fbfd28b582ff8e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "h2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "h2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "fnv 1.0.7",
+              "target": "fnv"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-sink 0.3.21",
+              "target": "futures_sink"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "indexmap"
+            },
+            {
+              "id": "slab 0.4.5",
+              "target": "slab"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tokio-util 0.6.9",
+              "target": "tokio_util"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.11"
+      },
+      "license": "MIT"
+    },
+    "hashbrown 0.11.2": {
+      "name": "hashbrown",
+      "version": "0.11.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hashbrown/0.11.2/download",
+          "sha256": "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hashbrown",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hashbrown",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "raw"
+        ],
+        "edition": "2018",
+        "version": "0.11.2"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "hermit-abi 0.1.19": {
+      "name": "hermit-abi",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+          "sha256": "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hermit_abi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hermit_abi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "http 0.2.6": {
+      "name": "http",
+      "version": "0.2.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/http/0.2.6/download",
+          "sha256": "31f4c6746584866f0feabcc69893c5b51beef3831656a968ed7ae254cdc4fd03"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "http",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "http",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "fnv 1.0.7",
+              "target": "fnv"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.6"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "http-body 0.4.4": {
+      "name": "http-body",
+      "version": "0.4.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/http-body/0.4.4/download",
+          "sha256": "1ff4f84919677303da5f147645dbea6b1881f368d03ac84e1dc09031ebd7b2c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "http_body",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "http_body",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.4"
+      },
+      "license": "MIT"
+    },
+    "http-range-header 0.3.0": {
+      "name": "http-range-header",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/http-range-header/0.3.0/download",
+          "sha256": "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "http_range_header",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "http_range_header",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "httparse 1.6.0": {
+      "name": "httparse",
+      "version": "1.6.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/httparse/1.6.0/download",
+          "sha256": "9100414882e15fb7feccb4897e5f0ff0ff1ca7d1a86a23208ada4d7a18e6c6c4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "httparse",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "httparse",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "httparse 1.6.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.6.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "httpdate 1.0.2": {
+      "name": "httpdate",
+      "version": "1.0.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/httpdate/1.0.2/download",
+          "sha256": "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "httpdate",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "httpdate",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.2"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "hyper 0.14.17": {
+      "name": "hyper",
+      "version": "0.14.17",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/hyper/0.14.17/download",
+          "sha256": "043f0e083e9901b6cc658a77d1eb86f4fc650bbb977a4337dd63192826aa85dd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "hyper",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "hyper",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "client",
+          "default",
+          "full",
+          "h2",
+          "http1",
+          "http2",
+          "runtime",
+          "server",
+          "socket2",
+          "stream",
+          "tcp"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-channel 0.3.21",
+              "target": "futures_channel"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "h2 0.3.11",
+              "target": "h2"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "http-body 0.4.4",
+              "target": "http_body"
+            },
+            {
+              "id": "httparse 1.6.0",
+              "target": "httparse"
+            },
+            {
+              "id": "httpdate 1.0.2",
+              "target": "httpdate"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tower-service 0.3.1",
+              "target": "tower_service"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            },
+            {
+              "id": "want 0.3.0",
+              "target": "want"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.14.17"
+      },
+      "license": "MIT"
+    },
+    "indexmap 1.8.0": {
+      "name": "indexmap",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/indexmap/1.8.0/download",
+          "sha256": "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "indexmap",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "indexmap",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "hashbrown 0.11.2",
+              "target": "hashbrown"
+            },
+            {
+              "id": "indexmap 1.8.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "autocfg 1.1.0",
+              "target": "autocfg"
+            }
+          ],
+          "selects": {}
+        }
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "itoa 1.0.1": {
+      "name": "itoa",
+      "version": "1.0.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/itoa/1.0.1/download",
+          "sha256": "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "itoa",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "itoa",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "lazy_static 1.4.0": {
+      "name": "lazy_static",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+          "sha256": "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lazy_static",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lazy_static",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "libc 0.2.119": {
+      "name": "libc",
+      "version": "0.2.119",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/libc/0.2.119/download",
+          "sha256": "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "libc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "libc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.2.119"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "lock_api 0.4.6": {
+      "name": "lock_api",
+      "version": "0.4.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/lock_api/0.4.6/download",
+          "sha256": "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "lock_api",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "lock_api",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "scopeguard 1.1.0",
+              "target": "scopeguard"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.6"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "log 0.4.14": {
+      "name": "log",
+      "version": "0.4.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/log/0.4.14/download",
+          "sha256": "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "matches 0.1.9": {
+      "name": "matches",
+      "version": "0.1.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/matches/0.1.9/download",
+          "sha256": "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "matches",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "matches",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.1.9"
+      },
+      "license": "MIT"
+    },
+    "matchit 0.4.6": {
+      "name": "matchit",
+      "version": "0.4.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/matchit/0.4.6/download",
+          "sha256": "9376a4f0340565ad675d11fc1419227faf5f60cd7ac9cb2e7185a471f30af833"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "matchit",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "matchit",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2018",
+        "version": "0.4.6"
+      },
+      "license": "MIT"
+    },
+    "memchr 2.4.1": {
+      "name": "memchr",
+      "version": "2.4.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+          "sha256": "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "memchr",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "memchr",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "memchr 2.4.1",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "2.4.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Unlicense/MIT"
+    },
+    "mime 0.3.16": {
+      "name": "mime",
+      "version": "0.3.16",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/mime/0.3.16/download",
+          "sha256": "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "mime",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "mime",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.3.16"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "mio 0.8.0": {
+      "name": "mio",
+      "version": "0.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/mio/0.8.0/download",
+          "sha256": "ba272f85fa0b41fc91872be579b3bbe0f56b792aa361a380eb669469f68dafb2"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "mio",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "mio",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "net",
+          "os-ext",
+          "os-poll"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "miow 0.3.7",
+                "target": "miow"
+              },
+              {
+                "id": "ntapi 0.3.7",
+                "target": "ntapi"
+              },
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.8.0"
+      },
+      "license": "MIT"
+    },
+    "miow 0.3.7": {
+      "name": "miow",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/miow/0.3.7/download",
+          "sha256": "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "miow",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "miow",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "ntapi 0.3.7": {
+      "name": "ntapi",
+      "version": "0.3.7",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ntapi/0.3.7/download",
+          "sha256": "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ntapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ntapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "user"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ntapi 0.3.7",
+              "target": "build_script_build"
+            },
+            {
+              "id": "winapi 0.3.9",
+              "target": "winapi"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.7"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "num_cpus 1.13.1": {
+      "name": "num_cpus",
+      "version": "1.13.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/num_cpus/1.13.1/download",
+          "sha256": "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "num_cpus",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "num_cpus",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [
+              {
+                "id": "hermit-abi 0.1.19",
+                "target": "hermit_abi"
+              }
+            ],
+            "cfg(not(windows))": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "1.13.1"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "once_cell 1.10.0": {
+      "name": "once_cell",
+      "version": "1.10.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/once_cell/1.10.0/download",
+          "sha256": "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "once_cell",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "once_cell",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "default",
+          "race",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "1.10.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "parking_lot 0.12.0": {
+      "name": "parking_lot",
+      "version": "0.12.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parking_lot/0.12.0/download",
+          "sha256": "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parking_lot",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parking_lot",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lock_api 0.4.6",
+              "target": "lock_api"
+            },
+            {
+              "id": "parking_lot_core 0.9.1",
+              "target": "parking_lot_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.12.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "parking_lot_core 0.9.1": {
+      "name": "parking_lot_core",
+      "version": "0.9.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/parking_lot_core/0.9.1/download",
+          "sha256": "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "parking_lot_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "parking_lot_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "parking_lot_core 0.9.1",
+              "target": "build_script_build"
+            },
+            {
+              "id": "smallvec 1.8.0",
+              "target": "smallvec"
+            }
+          ],
+          "selects": {
+            "cfg(target_os = \"redox\")": [
+              {
+                "id": "redox_syscall 0.2.11",
+                "target": "syscall"
+              }
+            ],
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "windows-sys 0.32.0",
+                "target": "windows_sys"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.9.1"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "percent-encoding 2.1.0": {
+      "name": "percent-encoding",
+      "version": "2.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/percent-encoding/2.1.0/download",
+          "sha256": "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "percent_encoding",
+            "crate_root": "lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "percent_encoding",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "2.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "pin-project 1.0.10": {
+      "name": "pin-project",
+      "version": "1.0.10",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project/1.0.10/download",
+          "sha256": "58ad3879ad3baf4e44784bc6a718a8698867bb991f8ce24d1bcbe2cfb4c3a75e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_project",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "pin-project-internal 1.0.10",
+              "target": "pin_project_internal"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.0.10"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-project-internal 1.0.10": {
+      "name": "pin-project-internal",
+      "version": "1.0.10",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project-internal/1.0.10/download",
+          "sha256": "744b6f092ba29c3650faf274db506afd39944f48420f6c86b17cfe0ee1cb36bb"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "pin_project_internal",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project_internal",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.10"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-project-lite 0.2.8": {
+      "name": "pin-project-lite",
+      "version": "0.2.8",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-project-lite/0.2.8/download",
+          "sha256": "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_project_lite",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_project_lite",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.2.8"
+      },
+      "license": "Apache-2.0 OR MIT"
+    },
+    "pin-utils 0.1.0": {
+      "name": "pin-utils",
+      "version": "0.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/pin-utils/0.1.0/download",
+          "sha256": "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "pin_utils",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "pin_utils",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "proc-macro2 1.0.36": {
+      "name": "proc-macro2",
+      "version": "1.0.36",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/proc-macro2/1.0.36/download",
+          "sha256": "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "proc_macro2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "proc_macro2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.36"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "quote 1.0.15": {
+      "name": "quote",
+      "version": "1.0.15",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/quote/1.0.15/download",
+          "sha256": "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "quote",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "quote",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "proc-macro"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.15"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "redox_syscall 0.2.11": {
+      "name": "redox_syscall",
+      "version": "0.2.11",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/redox_syscall/0.2.11/download",
+          "sha256": "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syscall",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syscall",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.11"
+      },
+      "license": "MIT"
+    },
+    "ryu 1.0.9": {
+      "name": "ryu",
+      "version": "1.0.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/ryu/1.0.9/download",
+          "sha256": "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "ryu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "ryu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.0.9"
+      },
+      "license": "Apache-2.0 OR BSL-1.0"
+    },
+    "scopeguard 1.1.0": {
+      "name": "scopeguard",
+      "version": "1.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/scopeguard/1.1.0/download",
+          "sha256": "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "scopeguard",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "scopeguard",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "1.1.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "serde 1.0.136": {
+      "name": "serde",
+      "version": "1.0.136",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde/1.0.136/download",
+          "sha256": "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "serde 1.0.136",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.0.136"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_json 1.0.79": {
+      "name": "serde_json",
+      "version": "1.0.79",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_json/1.0.79/download",
+          "sha256": "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_json",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_json",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "raw_value",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "ryu 1.0.9",
+              "target": "ryu"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            },
+            {
+              "id": "serde_json 1.0.79",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.79"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "serde_urlencoded 0.7.1": {
+      "name": "serde_urlencoded",
+      "version": "0.7.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/serde_urlencoded/0.7.1/download",
+          "sha256": "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "serde_urlencoded",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "serde_urlencoded",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "form_urlencoded 1.0.1",
+              "target": "form_urlencoded"
+            },
+            {
+              "id": "itoa 1.0.1",
+              "target": "itoa"
+            },
+            {
+              "id": "ryu 1.0.9",
+              "target": "ryu"
+            },
+            {
+              "id": "serde 1.0.136",
+              "target": "serde"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.1"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "sharded-slab 0.1.4": {
+      "name": "sharded-slab",
+      "version": "0.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/sharded-slab/0.1.4/download",
+          "sha256": "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "sharded_slab",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "sharded_slab",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.4"
+      },
+      "license": "MIT"
+    },
+    "signal-hook-registry 1.4.0": {
+      "name": "signal-hook-registry",
+      "version": "1.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/signal-hook-registry/1.4.0/download",
+          "sha256": "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "signal_hook_registry",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "signal_hook_registry",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "libc 0.2.119",
+              "target": "libc"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "1.4.0"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "slab 0.4.5": {
+      "name": "slab",
+      "version": "0.4.5",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/slab/0.4.5/download",
+          "sha256": "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "slab",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "slab",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "std"
+        ],
+        "edition": "2018",
+        "version": "0.4.5"
+      },
+      "license": "MIT"
+    },
+    "smallvec 1.8.0": {
+      "name": "smallvec",
+      "version": "1.8.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/smallvec/1.8.0/download",
+          "sha256": "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "smallvec",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "smallvec",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "1.8.0"
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "socket2 0.4.4": {
+      "name": "socket2",
+      "version": "0.4.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/socket2/0.4.4/download",
+          "sha256": "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "socket2",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "socket2",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "all"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.4.4"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "syn 1.0.86": {
+      "name": "syn",
+      "version": "1.0.86",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/syn/1.0.86/download",
+          "sha256": "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "syn",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "syn",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "clone-impls",
+          "default",
+          "derive",
+          "extra-traits",
+          "full",
+          "parsing",
+          "printing",
+          "proc-macro",
+          "quote",
+          "visit",
+          "visit-mut"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "build_script_build"
+            },
+            {
+              "id": "unicode-xid 0.2.2",
+              "target": "unicode_xid"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.86"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "sync_wrapper 0.1.1": {
+      "name": "sync_wrapper",
+      "version": "0.1.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/sync_wrapper/0.1.1/download",
+          "sha256": "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "sync_wrapper",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "sync_wrapper",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.1.1"
+      },
+      "license": "Apache-2.0"
+    },
+    "thread_local 1.1.4": {
+      "name": "thread_local",
+      "version": "1.1.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/thread_local/1.1.4/download",
+          "sha256": "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "thread_local",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "thread_local",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.1.4"
+      },
+      "license": "Apache-2.0/MIT"
+    },
+    "tokio 1.17.0": {
+      "name": "tokio",
+      "version": "1.17.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio/1.17.0/download",
+          "sha256": "2af73ac49756f3f7c01172e34a23e5d0216f6c32333757c2c61feb2bbff5a5ee"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "bytes",
+          "default",
+          "fs",
+          "full",
+          "io-std",
+          "io-util",
+          "libc",
+          "macros",
+          "memchr",
+          "mio",
+          "net",
+          "num_cpus",
+          "once_cell",
+          "parking_lot",
+          "process",
+          "rt",
+          "rt-multi-thread",
+          "signal",
+          "signal-hook-registry",
+          "socket2",
+          "sync",
+          "time",
+          "tokio-macros",
+          "winapi"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "memchr 2.4.1",
+              "target": "memchr"
+            },
+            {
+              "id": "mio 0.8.0",
+              "target": "mio"
+            },
+            {
+              "id": "num_cpus 1.13.1",
+              "target": "num_cpus"
+            },
+            {
+              "id": "once_cell 1.10.0",
+              "target": "once_cell"
+            },
+            {
+              "id": "parking_lot 0.12.0",
+              "target": "parking_lot"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "socket2 0.4.4",
+              "target": "socket2"
+            }
+          ],
+          "selects": {
+            "cfg(unix)": [
+              {
+                "id": "libc 0.2.119",
+                "target": "libc"
+              },
+              {
+                "id": "signal-hook-registry 1.4.0",
+                "target": "signal_hook_registry"
+              }
+            ],
+            "cfg(windows)": [
+              {
+                "id": "winapi 0.3.9",
+                "target": "winapi"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "tokio-macros 1.7.0",
+              "target": "tokio_macros"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "1.17.0"
+      },
+      "license": "MIT"
+    },
+    "tokio-macros 1.7.0": {
+      "name": "tokio-macros",
+      "version": "1.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-macros/1.7.0/download",
+          "sha256": "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "tokio_macros",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_macros",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.7.0"
+      },
+      "license": "MIT"
+    },
+    "tokio-util 0.6.9": {
+      "name": "tokio-util",
+      "version": "0.6.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-util/0.6.9/download",
+          "sha256": "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "codec",
+          "default"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-sink 0.3.21",
+              "target": "futures_sink"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.6.9"
+      },
+      "license": "MIT"
+    },
+    "tokio-util 0.7.0": {
+      "name": "tokio-util",
+      "version": "0.7.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tokio-util/0.7.0/download",
+          "sha256": "64910e1b9c1901aaf5375561e35b9c057d95ff41a44ede043a03e09279eabaf1"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tokio_util",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tokio_util",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-sink 0.3.21",
+              "target": "futures_sink"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.7.0"
+      },
+      "license": "MIT"
+    },
+    "tower 0.4.12": {
+      "name": "tower",
+      "version": "0.4.12",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tower/0.4.12/download",
+          "sha256": "9a89fd63ad6adf737582df5db40d286574513c69a11dac5214dc3b5603d6713e"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tower",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tower",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "__common",
+          "buffer",
+          "default",
+          "futures-core",
+          "futures-util",
+          "log",
+          "make",
+          "pin-project",
+          "pin-project-lite",
+          "tokio",
+          "tokio-util",
+          "tracing",
+          "util"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "pin-project 1.0.10",
+              "target": "pin_project"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tokio 1.17.0",
+              "target": "tokio"
+            },
+            {
+              "id": "tokio-util 0.7.0",
+              "target": "tokio_util"
+            },
+            {
+              "id": "tower-layer 0.3.1",
+              "target": "tower_layer"
+            },
+            {
+              "id": "tower-service 0.3.1",
+              "target": "tower_service"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.4.12"
+      },
+      "license": "MIT"
+    },
+    "tower-http 0.2.4": {
+      "name": "tower-http",
+      "version": "0.2.4",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tower-http/0.2.4/download",
+          "sha256": "90c125fdea84614a4368fd35786b51d0682ab8d42705e061e92f0b955dea40fb"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tower_http",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tower_http",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "map-response-body",
+          "tower",
+          "trace",
+          "tracing",
+          "util"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "bitflags 1.3.2",
+              "target": "bitflags"
+            },
+            {
+              "id": "bytes 1.1.0",
+              "target": "bytes"
+            },
+            {
+              "id": "futures-core 0.3.21",
+              "target": "futures_core"
+            },
+            {
+              "id": "futures-util 0.3.21",
+              "target": "futures_util"
+            },
+            {
+              "id": "http 0.2.6",
+              "target": "http"
+            },
+            {
+              "id": "http-body 0.4.4",
+              "target": "http_body"
+            },
+            {
+              "id": "http-range-header 0.3.0",
+              "target": "http_range_header"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tower 0.4.12",
+              "target": "tower"
+            },
+            {
+              "id": "tower-layer 0.3.1",
+              "target": "tower_layer"
+            },
+            {
+              "id": "tower-service 0.3.1",
+              "target": "tower_service"
+            },
+            {
+              "id": "tracing 0.1.31",
+              "target": "tracing"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.2.4"
+      },
+      "license": "MIT"
+    },
+    "tower-layer 0.3.1": {
+      "name": "tower-layer",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tower-layer/0.3.1/download",
+          "sha256": "343bc9466d3fe6b0f960ef45960509f84480bf4fd96f92901afe7ff3df9d3a62"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tower_layer",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tower_layer",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "tower-service 0.3.1": {
+      "name": "tower-service",
+      "version": "0.3.1",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tower-service/0.3.1/download",
+          "sha256": "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tower_service",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tower_service",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2018",
+        "version": "0.3.1"
+      },
+      "license": "MIT"
+    },
+    "tracing 0.1.31": {
+      "name": "tracing",
+      "version": "0.1.31",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing/0.1.31/download",
+          "sha256": "f6c650a8ef0cd2dd93736f033d21cbd1224c5a967aa0c258d00fcf7dafef9b9f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "attributes",
+          "default",
+          "log",
+          "std",
+          "tracing-attributes"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "cfg-if 1.0.0",
+              "target": "cfg_if"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "pin-project-lite 0.2.8",
+              "target": "pin_project_lite"
+            },
+            {
+              "id": "tracing-core 0.1.22",
+              "target": "tracing_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "tracing-attributes 0.1.19",
+              "target": "tracing_attributes"
+            }
+          ],
+          "selects": {}
+        },
+        "version": "0.1.31"
+      },
+      "license": "MIT"
+    },
+    "tracing-attributes 0.1.19": {
+      "name": "tracing-attributes",
+      "version": "0.1.19",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-attributes/0.1.19/download",
+          "sha256": "8276d9a4a3a558d7b7ad5303ad50b53d58264641b82914b7ada36bd762e7a716"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "tracing_attributes",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_attributes",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "proc-macro2 1.0.36",
+              "target": "proc_macro2"
+            },
+            {
+              "id": "quote 1.0.15",
+              "target": "quote"
+            },
+            {
+              "id": "syn 1.0.86",
+              "target": "syn"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.19"
+      },
+      "license": "MIT"
+    },
+    "tracing-core 0.1.22": {
+      "name": "tracing-core",
+      "version": "0.1.22",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-core/0.1.22/download",
+          "sha256": "03cfcb51380632a72d3111cb8d3447a8d908e577d31beeac006f836383d29a23"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing_core",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_core",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default",
+          "lazy_static",
+          "std",
+          "valuable"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            }
+          ],
+          "selects": {
+            "cfg(tracing_unstable)": [
+              {
+                "id": "valuable 0.1.0",
+                "target": "valuable"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.1.22"
+      },
+      "license": "MIT"
+    },
+    "tracing-log 0.1.2": {
+      "name": "tracing-log",
+      "version": "0.1.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-log/0.1.2/download",
+          "sha256": "a6923477a48e41c1951f1999ef8bb5a3023eb723ceadafe78ffb65dc366761e3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing_log",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_log",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "log-tracer",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "lazy_static 1.4.0",
+              "target": "lazy_static"
+            },
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "tracing-core 0.1.22",
+              "target": "tracing_core"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.2"
+      },
+      "license": "MIT"
+    },
+    "tracing-subscriber 0.3.9": {
+      "name": "tracing-subscriber",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/tracing-subscriber/0.3.9/download",
+          "sha256": "9e0ab7bdc962035a87fba73f3acca9b8a8d0034c2e6f60b84aeaaddddc155dce"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "tracing_subscriber",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "tracing_subscriber",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "ansi",
+          "ansi_term",
+          "default",
+          "fmt",
+          "registry",
+          "sharded-slab",
+          "smallvec",
+          "std",
+          "thread_local",
+          "tracing-log"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "ansi_term 0.12.1",
+              "target": "ansi_term"
+            },
+            {
+              "id": "sharded-slab 0.1.4",
+              "target": "sharded_slab"
+            },
+            {
+              "id": "smallvec 1.8.0",
+              "target": "smallvec"
+            },
+            {
+              "id": "thread_local 1.1.4",
+              "target": "thread_local"
+            },
+            {
+              "id": "tracing-core 0.1.22",
+              "target": "tracing_core"
+            },
+            {
+              "id": "tracing-log 0.1.2",
+              "target": "tracing_log"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.9"
+      },
+      "license": "MIT"
+    },
+    "try-lock 0.2.3": {
+      "name": "try-lock",
+      "version": "0.2.3",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/try-lock/0.2.3/download",
+          "sha256": "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "try_lock",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "try_lock",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "edition": "2015",
+        "version": "0.2.3"
+      },
+      "license": "MIT"
+    },
+    "unicode-xid 0.2.2": {
+      "name": "unicode-xid",
+      "version": "0.2.2",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+          "sha256": "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "unicode_xid",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "unicode_xid",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "default"
+        ],
+        "edition": "2015",
+        "version": "0.2.2"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "valuable 0.1.0": {
+      "name": "valuable",
+      "version": "0.1.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/valuable/0.1.0/download",
+          "sha256": "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "valuable",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "valuable",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "alloc",
+          "std"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "valuable 0.1.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.1.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT"
+    },
+    "want 0.3.0": {
+      "name": "want",
+      "version": "0.3.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/want/0.3.0/download",
+          "sha256": "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "want",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "want",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "log 0.4.14",
+              "target": "log"
+            },
+            {
+              "id": "try-lock 0.2.3",
+              "target": "try_lock"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.3.0"
+      },
+      "license": "MIT"
+    },
+    "winapi 0.3.9": {
+      "name": "winapi",
+      "version": "0.3.9",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+          "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "cfg",
+          "consoleapi",
+          "errhandlingapi",
+          "evntrace",
+          "fileapi",
+          "handleapi",
+          "in6addr",
+          "inaddr",
+          "ioapiset",
+          "minwinbase",
+          "minwindef",
+          "mswsock",
+          "namedpipeapi",
+          "ntdef",
+          "ntsecapi",
+          "processenv",
+          "std",
+          "synchapi",
+          "threadpoollegacyapiset",
+          "windef",
+          "winerror",
+          "winioctl",
+          "winsock2",
+          "ws2def",
+          "ws2ipdef",
+          "ws2tcpip"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi 0.3.9",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {
+            "i686-pc-windows-gnu": [
+              {
+                "id": "winapi-i686-pc-windows-gnu 0.4.0",
+                "target": "winapi_i686_pc_windows_gnu"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+                "target": "winapi_x86_64_pc_windows_gnu"
+              }
+            ]
+          }
+        },
+        "edition": "2015",
+        "version": "0.3.9"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-i686-pc-windows-gnu 0.4.0": {
+      "name": "winapi-i686-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+          "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_i686_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_i686_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-i686-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "winapi-x86_64-pc-windows-gnu 0.4.0": {
+      "name": "winapi-x86_64-pc-windows-gnu",
+      "version": "0.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+          "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "winapi_x86_64_pc_windows_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "winapi_x86_64_pc_windows_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "winapi-x86_64-pc-windows-gnu 0.4.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2015",
+        "version": "0.4.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT/Apache-2.0"
+    },
+    "windows-sys 0.32.0": {
+      "name": "windows-sys",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows-sys/0.32.0/download",
+          "sha256": "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_sys",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_sys",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "crate_features": [
+          "Win32",
+          "Win32_Foundation",
+          "Win32_System",
+          "Win32_System_LibraryLoader",
+          "Win32_System_SystemServices",
+          "Win32_System_WindowsProgramming",
+          "default"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "aarch64-pc-windows-msvc": [
+              {
+                "id": "windows_aarch64_msvc 0.32.0",
+                "target": "windows_aarch64_msvc"
+              }
+            ],
+            "aarch64-uwp-windows-msvc": [
+              {
+                "id": "windows_aarch64_msvc 0.32.0",
+                "target": "windows_aarch64_msvc"
+              }
+            ],
+            "i686-pc-windows-gnu": [
+              {
+                "id": "windows_i686_gnu 0.32.0",
+                "target": "windows_i686_gnu"
+              }
+            ],
+            "i686-pc-windows-msvc": [
+              {
+                "id": "windows_i686_msvc 0.32.0",
+                "target": "windows_i686_msvc"
+              }
+            ],
+            "i686-uwp-windows-gnu": [
+              {
+                "id": "windows_i686_gnu 0.32.0",
+                "target": "windows_i686_gnu"
+              }
+            ],
+            "i686-uwp-windows-msvc": [
+              {
+                "id": "windows_i686_msvc 0.32.0",
+                "target": "windows_i686_msvc"
+              }
+            ],
+            "x86_64-pc-windows-gnu": [
+              {
+                "id": "windows_x86_64_gnu 0.32.0",
+                "target": "windows_x86_64_gnu"
+              }
+            ],
+            "x86_64-pc-windows-msvc": [
+              {
+                "id": "windows_x86_64_msvc 0.32.0",
+                "target": "windows_x86_64_msvc"
+              }
+            ],
+            "x86_64-uwp-windows-gnu": [
+              {
+                "id": "windows_x86_64_gnu 0.32.0",
+                "target": "windows_x86_64_gnu"
+              }
+            ],
+            "x86_64-uwp-windows-msvc": [
+              {
+                "id": "windows_x86_64_msvc 0.32.0",
+                "target": "windows_x86_64_msvc"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "windows_aarch64_msvc 0.32.0": {
+      "name": "windows_aarch64_msvc",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows_aarch64_msvc/0.32.0/download",
+          "sha256": "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_aarch64_msvc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_aarch64_msvc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "windows_aarch64_msvc 0.32.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "windows_i686_gnu 0.32.0": {
+      "name": "windows_i686_gnu",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows_i686_gnu/0.32.0/download",
+          "sha256": "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_i686_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_i686_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "windows_i686_gnu 0.32.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "windows_i686_msvc 0.32.0": {
+      "name": "windows_i686_msvc",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows_i686_msvc/0.32.0/download",
+          "sha256": "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_i686_msvc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_i686_msvc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "windows_i686_msvc 0.32.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "windows_x86_64_gnu 0.32.0": {
+      "name": "windows_x86_64_gnu",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows_x86_64_gnu/0.32.0/download",
+          "sha256": "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_x86_64_gnu",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_x86_64_gnu",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "windows_x86_64_gnu 0.32.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
+    "windows_x86_64_msvc 0.32.0": {
+      "name": "windows_x86_64_msvc",
+      "version": "0.32.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/windows_x86_64_msvc/0.32.0/download",
+          "sha256": "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "windows_x86_64_msvc",
+            "crate_root": "src/lib.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": {
+              "include": [
+                "**/*.rs"
+              ],
+              "exclude": []
+            }
+          }
+        }
+      ],
+      "library_target_name": "windows_x86_64_msvc",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "windows_x86_64_msvc 0.32.0",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "0.32.0"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    }
+  },
+  "binary_crates": [],
+  "workspace_members": {
+    "direct-cargo-bazel-deps 0.0.1": ""
+  },
+  "conditions": {
+    "aarch64-pc-windows-msvc": [],
+    "aarch64-uwp-windows-msvc": [],
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(not(windows))": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "wasm32-unknown-unknown",
+      "wasm32-wasi",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"windows\")": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "cfg(tracing_unstable)": [],
+    "cfg(unix)": [
+      "aarch64-apple-darwin",
+      "aarch64-apple-ios",
+      "aarch64-linux-android",
+      "aarch64-unknown-linux-gnu",
+      "arm-unknown-linux-gnueabi",
+      "armv7-unknown-linux-gnueabi",
+      "i686-apple-darwin",
+      "i686-linux-android",
+      "i686-unknown-freebsd",
+      "i686-unknown-linux-gnu",
+      "powerpc-unknown-linux-gnu",
+      "s390x-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "x86_64-apple-ios",
+      "x86_64-linux-android",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu"
+    ],
+    "cfg(windows)": [
+      "i686-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ],
+    "i686-pc-windows-gnu": [],
+    "i686-pc-windows-msvc": [
+      "i686-pc-windows-msvc"
+    ],
+    "i686-uwp-windows-gnu": [],
+    "i686-uwp-windows-msvc": [],
+    "x86_64-pc-windows-gnu": [],
+    "x86_64-pc-windows-msvc": [
+      "x86_64-pc-windows-msvc"
+    ],
+    "x86_64-uwp-windows-gnu": [],
+    "x86_64-uwp-windows-msvc": []
+  }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/src/main.rs b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/src/main.rs
new file mode 100644
index 0000000..edde4b6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/no_cargo_manifests/src/main.rs
@@ -0,0 +1,150 @@
+//! Copied from https://github.com/tokio-rs/axum/blob/v0.2.5/examples/testing/src/main.rs
+
+use axum::{
+    routing::{get, post},
+    Json, Router,
+};
+use tower_http::trace::TraceLayer;
+
+#[tokio::main]
+async fn main() {
+    // Set the RUST_LOG, if it hasn't been explicitly defined
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "example_testing=debug,tower_http=debug")
+    }
+    tracing_subscriber::fmt::init();
+
+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 3000));
+
+    tracing::debug!("listening on {}", addr);
+
+    axum::Server::bind(&addr)
+        .serve(app().into_make_service())
+        .await
+        .unwrap();
+}
+
+/// Having a function that produces our app makes it easy to call it from tests
+/// without having to create an HTTP server.
+#[allow(dead_code)]
+fn app() -> Router {
+    Router::new()
+        .route("/", get(|| async { "Hello, World!" }))
+        .route(
+            "/json",
+            post(|payload: Json<serde_json::Value>| async move {
+                Json(serde_json::json!({ "data": payload.0 }))
+            }),
+        )
+        // We can still add middleware
+        .layer(TraceLayer::new_for_http())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(not(target_os = "windows"))]
+    use std::net::{SocketAddr, TcpListener};
+
+    use axum::{
+        body::Body,
+        http::{self, Request, StatusCode},
+    };
+    use serde_json::{json, Value};
+    use tower::ServiceExt; // for `app.oneshot()`
+
+    #[tokio::test]
+    async fn hello_world() {
+        let app = app();
+
+        // `Router` implements `tower::Service<Request<Body>>` so we can
+        // call it like any tower service, no need to run an HTTP server.
+        let response = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn json() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(http::Method::POST)
+                    .uri("/json")
+                    .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
+                    .body(Body::from(
+                        serde_json::to_vec(&json!([1_i8, 2_i8, 3_i8, 4_i8])).unwrap(),
+                    ))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        let body: Value = serde_json::from_slice(&body).unwrap();
+        assert_eq!(body, json!({ "data": [1_i8, 2_i8, 3_i8, 4_i8] }));
+    }
+
+    #[tokio::test]
+    async fn not_found() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/does-not-exist")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert!(body.is_empty());
+    }
+
+    // TODO: This test fails on Windows, it shouldn't but it's unclear to me
+    // if this is an issue on the host or with the test.
+    #[cfg(not(target_os = "windows"))]
+    // You can also spawn a server and talk to it like any other HTTP server:
+    #[tokio::test]
+    async fn the_real_deal() {
+        let listener = TcpListener::bind("0.0.0.0:0".parse::<SocketAddr>().unwrap()).unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        tokio::spawn(async move {
+            axum::Server::from_tcp(listener)
+                .unwrap()
+                .serve(app().into_make_service())
+                .await
+                .unwrap();
+        });
+
+        let client = hyper::Client::new();
+
+        let response = client
+            .request(
+                Request::builder()
+                    .uri(format!("http://{}", addr))
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/.gitignore b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/.gitignore
new file mode 100644
index 0000000..a1b775e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/.gitignore
@@ -0,0 +1,3 @@
+# Ignore everything but the `BUILD` files within the vendored directories
+crates/*/*
+!crates/*/BUILD.bazel
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/BUILD.bazel
new file mode 100644
index 0000000..19fef1d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/BUILD.bazel
@@ -0,0 +1,25 @@
+load("@rules_rust//crate_universe:defs.bzl", "crates_vendor")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+load("//vendor_local_manifests/crates:defs.bzl", "aliases", "all_crate_deps")
+
+crates_vendor(
+    name = "crates_vendor",
+    manifests = [":Cargo.toml"],
+    mode = "local",
+)
+
+rust_library(
+    name = "cargo_local",
+    srcs = glob(["**/*.rs"]),
+    aliases = aliases(),
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":cargo_local",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.lock b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.lock
new file mode 100644
index 0000000..3b522a3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.lock
@@ -0,0 +1,356 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "async-stream"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "171374e7e3b2504e0e5236e3b59260560f9fe94bfe9ac39ba5e4e929c5590625"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "648ed8c8d2ce5409ccd57453d9d1b214b342a0d69376a6feda1fd6cae3299308"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cargo_local"
+version = "0.1.0"
+dependencies = [
+ "tempfile",
+ "tokio",
+ "tokio-test",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "lock_api"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "mio"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"
+dependencies = [
+ "libc",
+ "log",
+ "miow",
+ "ntapi",
+ "winapi",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "libc",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "tokio"
+version = "1.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c27a64b625de6d309e8c57716ba93021dccf1b3b5c97edd6d3dd2d2135afc0a"
+dependencies = [
+ "bytes",
+ "libc",
+ "memchr",
+ "mio",
+ "num_cpus",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "tokio-macros",
+ "winapi",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50145484efff8818b5ccd256697f36863f587da82cf8b409c53adf1e840798e3"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.toml b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.toml
new file mode 100644
index 0000000..b798bfd
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "cargo_local"
+version = "0.1.0"
+authors = ["UebelAndre <github@uebelandre.com>"]
+edition = "2018"
+
+[dependencies]
+# TODO: For some reason this fails only for locally vendored crates
+# https://github.com/abrisco/cargo-bazel/issues/173
+tokio = { version = "=1.16.1", features = ["full"] }
+
+[dev-dependencies]
+tempfile = "3.2.0"
+tokio-test = "0.4.2"
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/BUILD.bazel
new file mode 100644
index 0000000..866840e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/BUILD.bazel
@@ -0,0 +1,46 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+alias(
+    name = "tempfile",
+    actual = "//vendor_local_manifests/crates/tempfile-3.3.0:tempfile",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio",
+    actual = "//vendor_local_manifests/crates/tokio-1.16.1:tokio",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio-test",
+    actual = "//vendor_local_manifests/crates/tokio-test-0.4.2:tokio_test",
+    tags = ["manual"],
+)
+
+# Binaries
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-0.3.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-0.3.2/BUILD.bazel
new file mode 100644
index 0000000..b6de9af
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-0.3.2/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "async_stream",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/async-stream-impl-0.3.2:async_stream_impl",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/futures-core-0.3.21:futures_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-impl-0.3.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-impl-0.3.2/BUILD.bazel
new file mode 100644
index 0000000..a33e572
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/async-stream-impl-0.3.2/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "async_stream_impl",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_manifests/crates/quote-1.0.15:quote",
+            "//vendor_local_manifests/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bitflags-1.3.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bitflags-1.3.2/BUILD.bazel
new file mode 100644
index 0000000..6894746
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bitflags-1.3.2/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bytes-1.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bytes-1.1.0/BUILD.bazel
new file mode 100644
index 0000000..b679f2e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/bytes-1.1.0/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "bytes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/cfg-if-1.0.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/cfg-if-1.0.0/BUILD.bazel
new file mode 100644
index 0000000..e4aab64
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/cfg-if-1.0.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/defs.bzl b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/defs.bzl
new file mode 100644
index 0000000..9950158
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/defs.bzl
@@ -0,0 +1,368 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = None):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {
+    "vendor_local_manifests": {
+        _COMMON_CONDITION: {
+            "tokio": "//vendor_local_manifests/crates/tokio-1.16.1:tokio",
+        },
+    },
+}
+
+_NORMAL_ALIASES = {
+    "vendor_local_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_NORMAL_DEV_DEPENDENCIES = {
+    "vendor_local_manifests": {
+        _COMMON_CONDITION: {
+            "tempfile": "//vendor_local_manifests/crates/tempfile-3.3.0:tempfile",
+            "tokio-test": "//vendor_local_manifests/crates/tokio-test-0.4.2:tokio_test",
+        },
+    },
+}
+
+_NORMAL_DEV_ALIASES = {
+    "vendor_local_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_PROC_MACRO_DEPENDENCIES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_PROC_MACRO_ALIASES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_PROC_MACRO_DEV_ALIASES = {
+    "vendor_local_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_BUILD_DEPENDENCIES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_BUILD_ALIASES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_BUILD_PROC_MACRO_ALIASES = {
+    "vendor_local_manifests": {
+    },
+}
+
+_CONDITIONS = {
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(any(unix, target_os = \"wasi\"))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(not(windows))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(target_arch = \"wasm32\")": ["wasm32-unknown-unknown", "wasm32-wasi"],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(unix)": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(windows)": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": [],
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/fastrand-1.7.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/fastrand-1.7.0/BUILD.bazel
new file mode 100644
index 0000000..a421204
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/fastrand-1.7.0/BUILD.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "fastrand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_arch = "wasm32")
+        (
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/instant-0.1.12:instant",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/futures-core-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/futures-core-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..fa2bd35
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/futures-core-0.3.21/BUILD.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/futures-core-0.3.21:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/hermit-abi-0.1.19/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/hermit-abi-0.1.19/BUILD.bazel
new file mode 100644
index 0000000..0d57813
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/hermit-abi-0.1.19/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/instant-0.1.12/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/instant-0.1.12/BUILD.bazel
new file mode 100644
index 0000000..3793223
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/instant-0.1.12/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "instant",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/libc-0.2.119/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/libc-0.2.119/BUILD.bazel
new file mode 100644
index 0000000..b41bc90
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/libc-0.2.119/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.119",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/libc-0.2.119:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "libc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.119",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "libc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/lock_api-0.4.6/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/lock_api-0.4.6/BUILD.bazel
new file mode 100644
index 0000000..4d93580
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/lock_api-0.4.6/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "lock_api",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/scopeguard-1.1.0:scopeguard",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/log-0.4.14/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/log-0.4.14/BUILD.bazel
new file mode 100644
index 0000000..b32f242
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/log-0.4.14/BUILD.bazel
@@ -0,0 +1,172 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/log-0.4.14:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "log_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "log_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/memchr-2.4.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/memchr-2.4.1/BUILD.bazel
new file mode 100644
index 0000000..29f02e0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/memchr-2.4.1/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "memchr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.4.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/memchr-2.4.1:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "memchr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "memchr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/mio-0.7.14/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/mio-0.7.14/BUILD.bazel
new file mode 100644
index 0000000..78472d8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/mio-0.7.14/BUILD.bazel
@@ -0,0 +1,132 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "mio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "net",
+        "os-ext",
+        "os-poll",
+        "os-util",
+        "tcp",
+        "udp",
+        "uds",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.14",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/log-0.4.14:log",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/miow-0.3.7:miow",
+            "//vendor_local_manifests/crates/ntapi-0.3.7:ntapi",
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/log-0.4.14:log",
+        ],
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/log-0.4.14:log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/miow-0.3.7/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/miow-0.3.7/BUILD.bazel
new file mode 100644
index 0000000..13a2472
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/miow-0.3.7/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "miow",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/ntapi-0.3.7/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/ntapi-0.3.7/BUILD.bazel
new file mode 100644
index 0000000..b90789b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/ntapi-0.3.7/BUILD.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "ntapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/ntapi-0.3.7:build_script_build",
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "ntapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "ntapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/num_cpus-1.13.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/num_cpus-1.13.1/BUILD.bazel
new file mode 100644
index 0000000..ecdf236
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/num_cpus-1.13.1/BUILD.bazel
@@ -0,0 +1,116 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.13.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))
+        #
+        # No supported platform triples for cfg: 'cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/once_cell-1.9.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/once_cell-1.9.0/BUILD.bazel
new file mode 100644
index 0000000..f2a936a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/once_cell-1.9.0/BUILD.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "once_cell",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "race",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot-0.11.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot-0.11.2/BUILD.bazel
new file mode 100644
index 0000000..4d944c2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot-0.11.2/BUILD.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/instant-0.1.12:instant",
+            "//vendor_local_manifests/crates/lock_api-0.4.6:lock_api",
+            "//vendor_local_manifests/crates/parking_lot_core-0.8.5:parking_lot_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot_core-0.8.5/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot_core-0.8.5/BUILD.bazel
new file mode 100644
index 0000000..0fc55d5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/parking_lot_core-0.8.5/BUILD.bazel
@@ -0,0 +1,222 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/instant-0.1.12:instant",
+            "//vendor_local_manifests/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_manifests/crates/smallvec-1.8.0:smallvec",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/instant-0.1.12:instant",
+            "//vendor_local_manifests/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_manifests/crates/smallvec-1.8.0:smallvec",
+        ],
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/instant-0.1.12:instant",
+            "//vendor_local_manifests/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_manifests/crates/smallvec-1.8.0:smallvec",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "parking_lot_core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.8.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "parking_lot_core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/pin-project-lite-0.2.8/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/pin-project-lite-0.2.8/BUILD.bazel
new file mode 100644
index 0000000..cfd3870
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/pin-project-lite-0.2.8/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project_lite",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/proc-macro2-1.0.36/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/proc-macro2-1.0.36/BUILD.bazel
new file mode 100644
index 0000000..95239eb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/proc-macro2-1.0.36/BUILD.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.36",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/proc-macro2-1.0.36:build_script_build",
+            "//vendor_local_manifests/crates/unicode-xid-0.2.2:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro2_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.36",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro2_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/quote-1.0.15/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/quote-1.0.15/BUILD.bazel
new file mode 100644
index 0000000..3c8a69f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/quote-1.0.15/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "quote",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/proc-macro2-1.0.36:proc_macro2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/redox_syscall-0.2.11/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/redox_syscall-0.2.11/BUILD.bazel
new file mode 100644
index 0000000..9057648
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/redox_syscall-0.2.11/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "syscall",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/bitflags-1.3.2:bitflags",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/remove_dir_all-0.5.3/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/remove_dir_all-0.5.3/BUILD.bazel
new file mode 100644
index 0000000..9b8cded
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/remove_dir_all-0.5.3/BUILD.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "remove_dir_all",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.5.3",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/scopeguard-1.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/scopeguard-1.1.0/BUILD.bazel
new file mode 100644
index 0000000..0bc1e13
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/scopeguard-1.1.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/signal-hook-registry-1.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/signal-hook-registry-1.4.0/BUILD.bazel
new file mode 100644
index 0000000..022c182
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/signal-hook-registry-1.4.0/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "signal_hook_registry",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/smallvec-1.8.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/smallvec-1.8.0/BUILD.bazel
new file mode 100644
index 0000000..a9ae389
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/smallvec-1.8.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/syn-1.0.86/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/syn-1.0.86/BUILD.bazel
new file mode 100644
index 0000000..0b72df3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/syn-1.0.86/BUILD.bazel
@@ -0,0 +1,194 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "syn",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit-mut",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.86",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_manifests/crates/quote-1.0.15:quote",
+            "//vendor_local_manifests/crates/syn-1.0.86:build_script_build",
+            "//vendor_local_manifests/crates/unicode-xid-0.2.2:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "syn_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit-mut",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.86",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "syn_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tempfile-3.3.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tempfile-3.3.0/BUILD.bazel
new file mode 100644
index 0000000..d685cc8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tempfile-3.3.0/BUILD.bazel
@@ -0,0 +1,134 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "tempfile",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "3.3.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(any(unix, target_os = "wasi"))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/fastrand-1.7.0:fastrand",
+            "//vendor_local_manifests/crates/remove_dir_all-0.5.3:remove_dir_all",
+        ],
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/fastrand-1.7.0:fastrand",
+            "//vendor_local_manifests/crates/remove_dir_all-0.5.3:remove_dir_all",
+        ],
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_manifests/crates/fastrand-1.7.0:fastrand",
+            "//vendor_local_manifests/crates/remove_dir_all-0.5.3:remove_dir_all",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-1.16.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-1.16.1/BUILD.bazel
new file mode 100644
index 0000000..3e662a5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-1.16.1/BUILD.bazel
@@ -0,0 +1,166 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bytes",
+        "default",
+        "fs",
+        "full",
+        "io-std",
+        "io-util",
+        "libc",
+        "macros",
+        "memchr",
+        "mio",
+        "net",
+        "num_cpus",
+        "once_cell",
+        "parking_lot",
+        "process",
+        "rt",
+        "rt-multi-thread",
+        "signal",
+        "signal-hook-registry",
+        "sync",
+        "test-util",
+        "time",
+        "tokio-macros",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/tokio-macros-1.7.0:tokio_macros",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.16.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/libc-0.2.119:libc",
+            "//vendor_local_manifests/crates/signal-hook-registry-1.4.0:signal_hook_registry",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/bytes-1.1.0:bytes",
+            "//vendor_local_manifests/crates/memchr-2.4.1:memchr",
+            "//vendor_local_manifests/crates/mio-0.7.14:mio",
+            "//vendor_local_manifests/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_manifests/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_manifests/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_manifests/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_manifests/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_manifests/crates/bytes-1.1.0:bytes",
+            "//vendor_local_manifests/crates/memchr-2.4.1:memchr",
+            "//vendor_local_manifests/crates/mio-0.7.14:mio",
+            "//vendor_local_manifests/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_manifests/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_manifests/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_manifests/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/bytes-1.1.0:bytes",
+            "//vendor_local_manifests/crates/memchr-2.4.1:memchr",
+            "//vendor_local_manifests/crates/mio-0.7.14:mio",
+            "//vendor_local_manifests/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_manifests/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_manifests/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_manifests/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-macros-1.7.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-macros-1.7.0/BUILD.bazel
new file mode 100644
index 0000000..ba51873
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-macros-1.7.0/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tokio_macros",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_manifests/crates/quote-1.0.15:quote",
+            "//vendor_local_manifests/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-stream-0.1.8/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-stream-0.1.8/BUILD.bazel
new file mode 100644
index 0000000..bdc973a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-stream-0.1.8/BUILD.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_stream",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "time",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_manifests/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_manifests/crates/tokio-1.16.1:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-test-0.4.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-test-0.4.2/BUILD.bazel
new file mode 100644
index 0000000..6ecccfc
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/tokio-test-0.4.2/BUILD.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_test",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/async-stream-0.3.2:async_stream",
+            "//vendor_local_manifests/crates/bytes-1.1.0:bytes",
+            "//vendor_local_manifests/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_manifests/crates/tokio-1.16.1:tokio",
+            "//vendor_local_manifests/crates/tokio-stream-0.1.8:tokio_stream",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/unicode-xid-0.2.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/unicode-xid-0.2.2/BUILD.bazel
new file mode 100644
index 0000000..30562c1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/unicode-xid-0.2.2/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-0.3.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-0.3.9/BUILD.bazel
new file mode 100644
index 0000000..28e223c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-0.3.9/BUILD.bazel
@@ -0,0 +1,237 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-i686-pc-windows-gnu 0.4.0","target":"winapi_i686_pc_windows_gnu"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-x86_64-pc-windows-gnu 0.4.0","target":"winapi_x86_64_pc_windows_gnu"}]
+        #
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/winapi-0.3.9:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel
new file mode 100644
index 0000000..fbf405f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/winapi-i686-pc-windows-gnu-0.4.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-i686-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-i686-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel
new file mode 100644
index 0000000..f0fe920
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_manifests/crates/winapi-x86_64-pc-windows-gnu-0.4.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-x86_64-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-x86_64-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/src/lib.rs b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/src/lib.rs
new file mode 100644
index 0000000..0e49d04
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_manifests/src/lib.rs
@@ -0,0 +1,44 @@
+use std::path::Path;
+
+use tokio::fs::File;
+use tokio::io::{AsyncBufReadExt, BufReader};
+
+pub async fn fill_buf_file(path: &Path) -> Vec<u8> {
+    let file = File::open(path).await.unwrap();
+    let mut file = BufReader::new(file);
+
+    let mut contents = Vec::new();
+
+    loop {
+        let consumed = {
+            let buffer = file.fill_buf().await.unwrap();
+            if buffer.is_empty() {
+                break;
+            }
+            contents.extend_from_slice(buffer);
+            buffer.len()
+        };
+
+        file.consume(consumed);
+    }
+
+    contents
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use tempfile::NamedTempFile;
+    use tokio_test::assert_ok;
+
+    #[tokio::test]
+    async fn test_fill_buf_file() {
+        let file = NamedTempFile::new().unwrap();
+        assert_ok!(std::fs::write(file.path(), b"hello"));
+
+        let contents = fill_buf_file(file.path()).await;
+
+        assert_eq!(contents, b"hello");
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/.gitignore b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/.gitignore
new file mode 100644
index 0000000..a1b775e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/.gitignore
@@ -0,0 +1,3 @@
+# Ignore everything but the `BUILD` files within the vendored directories
+crates/*/*
+!crates/*/BUILD.bazel
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/BUILD.bazel
new file mode 100644
index 0000000..b04b739
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/BUILD.bazel
@@ -0,0 +1,72 @@
+load("@rules_rust//crate_universe:defs.bzl", "crate", "crates_vendor")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
+
+crates_vendor(
+    name = "crates_vendor",
+    annotations = {
+        "axum": [crate.annotation(
+            compile_data_glob = ["**/*.md"],
+        )],
+    },
+    mode = "local",
+    packages = {
+        "axum": crate.spec(
+            version = "0.4.0",
+        ),
+        "hyper": crate.spec(
+            features = ["full"],
+            version = "0.14",
+        ),
+        "mime": crate.spec(
+            version = "0.3",
+        ),
+        "serde_json": crate.spec(
+            version = "1.0",
+        ),
+        # TODO: This is pinned due to a build failure introduced by 1.17
+        # bringing in windows-sys and introduces linker errors.
+        # https://github.com/abrisco/cargo-bazel/issues/173
+        "tokio": crate.spec(
+            features = ["full"],
+            version = "=1.16.1",
+        ),
+        "tower": crate.spec(
+            features = ["util"],
+            version = "0.4",
+        ),
+        "tower-http": crate.spec(
+            features = ["trace"],
+            version = "0.2.1",
+        ),
+        "tracing": crate.spec(
+            version = "0.1",
+        ),
+        "tracing-subscriber": crate.spec(
+            version = "0.3",
+        ),
+    },
+)
+
+rust_binary(
+    name = "vendor_local",
+    srcs = glob(["**/*.rs"]),
+    edition = "2018",
+    deps = [
+        "//vendor_local_pkgs/crates:axum",
+        "//vendor_local_pkgs/crates:hyper",
+        "//vendor_local_pkgs/crates:mime",
+        "//vendor_local_pkgs/crates:serde_json",
+        "//vendor_local_pkgs/crates:tokio",
+        "//vendor_local_pkgs/crates:tower",
+        "//vendor_local_pkgs/crates:tower-http",
+        "//vendor_local_pkgs/crates:tracing",
+        "//vendor_local_pkgs/crates:tracing-subscriber",
+    ],
+)
+
+rust_test(
+    name = "unit_test",
+    srcs = glob(["**/*.rs"]),
+    crate = ":vendor_local",
+    edition = "2018",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/BUILD.bazel
new file mode 100644
index 0000000..3e93a62
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/BUILD.bazel
@@ -0,0 +1,82 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+alias(
+    name = "axum",
+    actual = "//vendor_local_pkgs/crates/axum-0.4.8:axum",
+    tags = ["manual"],
+)
+
+alias(
+    name = "hyper",
+    actual = "//vendor_local_pkgs/crates/hyper-0.14.17:hyper",
+    tags = ["manual"],
+)
+
+alias(
+    name = "mime",
+    actual = "//vendor_local_pkgs/crates/mime-0.3.16:mime",
+    tags = ["manual"],
+)
+
+alias(
+    name = "serde_json",
+    actual = "//vendor_local_pkgs/crates/serde_json-1.0.79:serde_json",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio",
+    actual = "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tower",
+    actual = "//vendor_local_pkgs/crates/tower-0.4.12:tower",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tower-http",
+    actual = "//vendor_local_pkgs/crates/tower-http-0.2.3:tower_http",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tracing",
+    actual = "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tracing-subscriber",
+    actual = "//vendor_local_pkgs/crates/tracing-subscriber-0.3.9:tracing_subscriber",
+    tags = ["manual"],
+)
+
+# Binaries
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ansi_term-0.12.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ansi_term-0.12.1/BUILD.bazel
new file mode 100644
index 0000000..8fd8de6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ansi_term-0.12.1/BUILD.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "ansi_term",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.12.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "windows")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/async-trait-0.1.52/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/async-trait-0.1.52/BUILD.bazel
new file mode 100644
index 0000000..ec371b8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/async-trait-0.1.52/BUILD.bazel
@@ -0,0 +1,174 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "async_trait",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.52",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/async-trait-0.1.52:build_script_build",
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_pkgs/crates/quote-1.0.15:quote",
+            "//vendor_local_pkgs/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "async-trait_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.52",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "async-trait_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/autocfg-1.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/autocfg-1.1.0/BUILD.bazel
new file mode 100644
index 0000000..bd2fcd9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/autocfg-1.1.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-0.4.8/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-0.4.8/BUILD.bazel
new file mode 100644
index 0000000..92fea8b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-0.4.8/BUILD.bazel
@@ -0,0 +1,114 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "axum",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob([
+        "**",
+        "**/*.md",
+    ]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "http1",
+        "json",
+        "serde_json",
+        "tower-log",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/async-trait-0.1.52:async_trait",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/axum-core-0.1.2:axum_core",
+            "//vendor_local_pkgs/crates/bitflags-1.3.2:bitflags",
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/http-body-0.4.4:http_body",
+            "//vendor_local_pkgs/crates/hyper-0.14.17:hyper",
+            "//vendor_local_pkgs/crates/matchit-0.4.6:matchit",
+            "//vendor_local_pkgs/crates/memchr-2.4.1:memchr",
+            "//vendor_local_pkgs/crates/mime-0.3.16:mime",
+            "//vendor_local_pkgs/crates/percent-encoding-2.1.0:percent_encoding",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/serde-1.0.136:serde",
+            "//vendor_local_pkgs/crates/serde_json-1.0.79:serde_json",
+            "//vendor_local_pkgs/crates/serde_urlencoded-0.7.1:serde_urlencoded",
+            "//vendor_local_pkgs/crates/sync_wrapper-0.1.1:sync_wrapper",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+            "//vendor_local_pkgs/crates/tower-0.4.12:tower",
+            "//vendor_local_pkgs/crates/tower-http-0.2.3:tower_http",
+            "//vendor_local_pkgs/crates/tower-layer-0.3.1:tower_layer",
+            "//vendor_local_pkgs/crates/tower-service-0.3.1:tower_service",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-core-0.1.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-core-0.1.2/BUILD.bazel
new file mode 100644
index 0000000..1d5427f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/axum-core-0.1.2/BUILD.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "axum_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/async-trait-0.1.52:async_trait",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/http-body-0.4.4:http_body",
+            "//vendor_local_pkgs/crates/mime-0.3.16:mime",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bitflags-1.3.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bitflags-1.3.2/BUILD.bazel
new file mode 100644
index 0000000..6894746
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bitflags-1.3.2/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bytes-1.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bytes-1.1.0/BUILD.bazel
new file mode 100644
index 0000000..b679f2e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/bytes-1.1.0/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "bytes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/cfg-if-1.0.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/cfg-if-1.0.0/BUILD.bazel
new file mode 100644
index 0000000..e4aab64
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/cfg-if-1.0.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/defs.bzl b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/defs.bzl
new file mode 100644
index 0000000..00a5273
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/defs.bzl
@@ -0,0 +1,368 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = None):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {
+    "": {
+        _COMMON_CONDITION: {
+            "axum": "//vendor_local_pkgs/crates/axum-0.4.8:axum",
+            "hyper": "//vendor_local_pkgs/crates/hyper-0.14.17:hyper",
+            "mime": "//vendor_local_pkgs/crates/mime-0.3.16:mime",
+            "serde_json": "//vendor_local_pkgs/crates/serde_json-1.0.79:serde_json",
+            "tokio": "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+            "tower": "//vendor_local_pkgs/crates/tower-0.4.12:tower",
+            "tower-http": "//vendor_local_pkgs/crates/tower-http-0.2.3:tower_http",
+            "tracing": "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+            "tracing-subscriber": "//vendor_local_pkgs/crates/tracing-subscriber-0.3.9:tracing_subscriber",
+        },
+    },
+}
+
+_NORMAL_ALIASES = {
+    "": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_NORMAL_DEV_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_NORMAL_DEV_ALIASES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_ALIASES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEV_ALIASES = {
+    "": {
+    },
+}
+
+_BUILD_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_BUILD_ALIASES = {
+    "": {
+    },
+}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_BUILD_PROC_MACRO_ALIASES = {
+    "": {
+    },
+}
+
+_CONDITIONS = {
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(not(windows))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"windows\")": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "cfg(tracing_unstable)": [],
+    "cfg(unix)": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(windows)": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": [],
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/fnv-1.0.7/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/fnv-1.0.7/BUILD.bazel
new file mode 100644
index 0000000..9b3c6e3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/fnv-1.0.7/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 / MIT
+# ])
+
+rust_library(
+    name = "fnv",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/form_urlencoded-1.0.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/form_urlencoded-1.0.1/BUILD.bazel
new file mode 100644
index 0000000..9b0711c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/form_urlencoded-1.0.1/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "form_urlencoded",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/matches-0.1.9:matches",
+            "//vendor_local_pkgs/crates/percent-encoding-2.1.0:percent_encoding",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-channel-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-channel-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..63a38dd
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-channel-0.3.21/BUILD.bazel
@@ -0,0 +1,178 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_channel",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/futures-channel-0.3.21:build_script_build",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-channel_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-channel_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-core-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-core-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..fe1f1cb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-core-0.3.21/BUILD.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-sink-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-sink-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..cbdd96f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-sink-0.3.21/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_sink",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-task-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-task-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..20bc494
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-task-0.3.21/BUILD.bazel
@@ -0,0 +1,173 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_task",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/futures-task-0.3.21:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-task_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-task_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-util-0.3.21/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-util-0.3.21/BUILD.bazel
new file mode 100644
index 0000000..99d0ccd
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/futures-util-0.3.21/BUILD.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-task-0.3.21:futures_task",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:build_script_build",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/pin-utils-0.1.0:pin_utils",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-util_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-util_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/h2-0.3.11/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/h2-0.3.11/BUILD.bazel
new file mode 100644
index 0000000..3aa6ad9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/h2-0.3.11/BUILD.bazel
@@ -0,0 +1,95 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "h2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/fnv-1.0.7:fnv",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-sink-0.3.21:futures_sink",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/indexmap-1.8.0:indexmap",
+            "//vendor_local_pkgs/crates/slab-0.4.5:slab",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+            "//vendor_local_pkgs/crates/tokio-util-0.6.9:tokio_util",
+            "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hashbrown-0.11.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hashbrown-0.11.2/BUILD.bazel
new file mode 100644
index 0000000..54a071b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hashbrown-0.11.2/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "hashbrown",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "raw",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hermit-abi-0.1.19/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hermit-abi-0.1.19/BUILD.bazel
new file mode 100644
index 0000000..8bc328d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hermit-abi-0.1.19/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-0.2.6/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-0.2.6/BUILD.bazel
new file mode 100644
index 0000000..f2128d1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-0.2.6/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "http",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/fnv-1.0.7:fnv",
+            "//vendor_local_pkgs/crates/itoa-1.0.1:itoa",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-body-0.4.4/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-body-0.4.4/BUILD.bazel
new file mode 100644
index 0000000..e2010e3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-body-0.4.4/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "http_body",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-range-header-0.3.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-range-header-0.3.0/BUILD.bazel
new file mode 100644
index 0000000..c2d71d8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/http-range-header-0.3.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "http_range_header",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httparse-1.6.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httparse-1.6.0/BUILD.bazel
new file mode 100644
index 0000000..34dfd8b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httparse-1.6.0/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "httparse",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.6.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/httparse-1.6.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "httparse_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.6.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "httparse_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httpdate-1.0.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httpdate-1.0.2/BUILD.bazel
new file mode 100644
index 0000000..16d4a28
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/httpdate-1.0.2/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "httpdate",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hyper-0.14.17/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hyper-0.14.17/BUILD.bazel
new file mode 100644
index 0000000..8120d34
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/hyper-0.14.17/BUILD.bazel
@@ -0,0 +1,111 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "hyper",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "client",
+        "default",
+        "full",
+        "h2",
+        "http1",
+        "http2",
+        "runtime",
+        "server",
+        "socket2",
+        "stream",
+        "tcp",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.17",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-channel-0.3.21:futures_channel",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/h2-0.3.11:h2",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/http-body-0.4.4:http_body",
+            "//vendor_local_pkgs/crates/httparse-1.6.0:httparse",
+            "//vendor_local_pkgs/crates/httpdate-1.0.2:httpdate",
+            "//vendor_local_pkgs/crates/itoa-1.0.1:itoa",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/socket2-0.4.4:socket2",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+            "//vendor_local_pkgs/crates/tower-service-0.3.1:tower_service",
+            "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+            "//vendor_local_pkgs/crates/want-0.3.0:want",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/indexmap-1.8.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/indexmap-1.8.0/BUILD.bazel
new file mode 100644
index 0000000..dca71c5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/indexmap-1.8.0/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "indexmap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/hashbrown-0.11.2:hashbrown",
+            "//vendor_local_pkgs/crates/indexmap-1.8.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "indexmap_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.8.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/autocfg-1.1.0:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "indexmap_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/instant-0.1.12/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/instant-0.1.12/BUILD.bazel
new file mode 100644
index 0000000..e6d64d7
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/instant-0.1.12/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "instant",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/itoa-1.0.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/itoa-1.0.1/BUILD.bazel
new file mode 100644
index 0000000..69bfcf9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/itoa-1.0.1/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "itoa",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lazy_static-1.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lazy_static-1.4.0/BUILD.bazel
new file mode 100644
index 0000000..aabde66
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lazy_static-1.4.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/libc-0.2.119/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/libc-0.2.119/BUILD.bazel
new file mode 100644
index 0000000..5728a21
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/libc-0.2.119/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.119",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/libc-0.2.119:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "libc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.119",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "libc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lock_api-0.4.6/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lock_api-0.4.6/BUILD.bazel
new file mode 100644
index 0000000..e0a626e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/lock_api-0.4.6/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "lock_api",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/scopeguard-1.1.0:scopeguard",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/log-0.4.14/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/log-0.4.14/BUILD.bazel
new file mode 100644
index 0000000..ddae413
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/log-0.4.14/BUILD.bazel
@@ -0,0 +1,174 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_pkgs/crates/log-0.4.14:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "log_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "log_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matches-0.1.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matches-0.1.9/BUILD.bazel
new file mode 100644
index 0000000..b2ec92b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matches-0.1.9/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "matches",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matchit-0.4.6/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matchit-0.4.6/BUILD.bazel
new file mode 100644
index 0000000..dd3406b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/matchit-0.4.6/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "matchit",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/memchr-2.4.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/memchr-2.4.1/BUILD.bazel
new file mode 100644
index 0000000..316b2a2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/memchr-2.4.1/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "memchr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.4.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/memchr-2.4.1:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "memchr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "memchr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mime-0.3.16/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mime-0.3.16/BUILD.bazel
new file mode 100644
index 0000000..d7f8128
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mime-0.3.16/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "mime",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.16",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mio-0.7.14/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mio-0.7.14/BUILD.bazel
new file mode 100644
index 0000000..3995b37
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/mio-0.7.14/BUILD.bazel
@@ -0,0 +1,132 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "mio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "net",
+        "os-ext",
+        "os-poll",
+        "os-util",
+        "tcp",
+        "udp",
+        "uds",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.14",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/miow-0.3.7:miow",
+            "//vendor_local_pkgs/crates/ntapi-0.3.7:ntapi",
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+        ],
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/miow-0.3.7/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/miow-0.3.7/BUILD.bazel
new file mode 100644
index 0000000..1bca438
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/miow-0.3.7/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "miow",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ntapi-0.3.7/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ntapi-0.3.7/BUILD.bazel
new file mode 100644
index 0000000..0ada3ac
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ntapi-0.3.7/BUILD.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "ntapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/ntapi-0.3.7:build_script_build",
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "ntapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "ntapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/num_cpus-1.13.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/num_cpus-1.13.1/BUILD.bazel
new file mode 100644
index 0000000..55e897d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/num_cpus-1.13.1/BUILD.bazel
@@ -0,0 +1,116 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.13.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))
+        #
+        # No supported platform triples for cfg: 'cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/once_cell-1.9.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/once_cell-1.9.0/BUILD.bazel
new file mode 100644
index 0000000..f2a936a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/once_cell-1.9.0/BUILD.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "once_cell",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "race",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot-0.11.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot-0.11.2/BUILD.bazel
new file mode 100644
index 0000000..9cc5a37
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot-0.11.2/BUILD.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/instant-0.1.12:instant",
+            "//vendor_local_pkgs/crates/lock_api-0.4.6:lock_api",
+            "//vendor_local_pkgs/crates/parking_lot_core-0.8.5:parking_lot_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot_core-0.8.5/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot_core-0.8.5/BUILD.bazel
new file mode 100644
index 0000000..adbd416
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/parking_lot_core-0.8.5/BUILD.bazel
@@ -0,0 +1,222 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_pkgs/crates/instant-0.1.12:instant",
+            "//vendor_local_pkgs/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_pkgs/crates/smallvec-1.8.0:smallvec",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_pkgs/crates/instant-0.1.12:instant",
+            "//vendor_local_pkgs/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_pkgs/crates/smallvec-1.8.0:smallvec",
+        ],
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_pkgs/crates/instant-0.1.12:instant",
+            "//vendor_local_pkgs/crates/parking_lot_core-0.8.5:build_script_build",
+            "//vendor_local_pkgs/crates/smallvec-1.8.0:smallvec",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "parking_lot_core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.8.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "parking_lot_core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/percent-encoding-2.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/percent-encoding-2.1.0/BUILD.bazel
new file mode 100644
index 0000000..1ad467a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/percent-encoding-2.1.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "percent_encoding",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-1.0.10/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-1.0.10/BUILD.bazel
new file mode 100644
index 0000000..50eb667
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-1.0.10/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/pin-project-internal-1.0.10:pin_project_internal",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.10",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-internal-1.0.10/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-internal-1.0.10/BUILD.bazel
new file mode 100644
index 0000000..d9fe346
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-internal-1.0.10/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_proc_macro(
+    name = "pin_project_internal",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.10",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_pkgs/crates/quote-1.0.15:quote",
+            "//vendor_local_pkgs/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-lite-0.2.8/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-lite-0.2.8/BUILD.bazel
new file mode 100644
index 0000000..cfd3870
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-project-lite-0.2.8/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project_lite",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-utils-0.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-utils-0.1.0/BUILD.bazel
new file mode 100644
index 0000000..de4c1a2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/pin-utils-0.1.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "pin_utils",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/proc-macro2-1.0.36/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/proc-macro2-1.0.36/BUILD.bazel
new file mode 100644
index 0000000..ab8ac7d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/proc-macro2-1.0.36/BUILD.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.36",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:build_script_build",
+            "//vendor_local_pkgs/crates/unicode-xid-0.2.2:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro2_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.36",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro2_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/quote-1.0.15/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/quote-1.0.15/BUILD.bazel
new file mode 100644
index 0000000..f11544c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/quote-1.0.15/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "quote",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/redox_syscall-0.2.11/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/redox_syscall-0.2.11/BUILD.bazel
new file mode 100644
index 0000000..ff935f0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/redox_syscall-0.2.11/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "syscall",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bitflags-1.3.2:bitflags",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ryu-1.0.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ryu-1.0.9/BUILD.bazel
new file mode 100644
index 0000000..c2a9c81
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/ryu-1.0.9/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR BSL-1.0
+# ])
+
+rust_library(
+    name = "ryu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/scopeguard-1.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/scopeguard-1.1.0/BUILD.bazel
new file mode 100644
index 0000000..0bc1e13
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/scopeguard-1.1.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde-1.0.136/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde-1.0.136/BUILD.bazel
new file mode 100644
index 0000000..16a6c19
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde-1.0.136/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.136",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/serde-1.0.136:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.136",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_json-1.0.79/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_json-1.0.79/BUILD.bazel
new file mode 100644
index 0000000..7c55f8d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_json-1.0.79/BUILD.bazel
@@ -0,0 +1,180 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde_json",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "raw_value",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.79",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/itoa-1.0.1:itoa",
+            "//vendor_local_pkgs/crates/ryu-1.0.9:ryu",
+            "//vendor_local_pkgs/crates/serde-1.0.136:serde",
+            "//vendor_local_pkgs/crates/serde_json-1.0.79:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_json_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "raw_value",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.79",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_json_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_urlencoded-0.7.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_urlencoded-0.7.1/BUILD.bazel
new file mode 100644
index 0000000..98e60e9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/serde_urlencoded-0.7.1/BUILD.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "serde_urlencoded",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/form_urlencoded-1.0.1:form_urlencoded",
+            "//vendor_local_pkgs/crates/itoa-1.0.1:itoa",
+            "//vendor_local_pkgs/crates/ryu-1.0.9:ryu",
+            "//vendor_local_pkgs/crates/serde-1.0.136:serde",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sharded-slab-0.1.4/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sharded-slab-0.1.4/BUILD.bazel
new file mode 100644
index 0000000..8731db1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sharded-slab-0.1.4/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "sharded_slab",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/lazy_static-1.4.0:lazy_static",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/signal-hook-registry-1.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/signal-hook-registry-1.4.0/BUILD.bazel
new file mode 100644
index 0000000..e41c37a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/signal-hook-registry-1.4.0/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "signal_hook_registry",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/slab-0.4.5/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/slab-0.4.5/BUILD.bazel
new file mode 100644
index 0000000..d4303ef
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/slab-0.4.5/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "slab",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.5",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/smallvec-1.8.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/smallvec-1.8.0/BUILD.bazel
new file mode 100644
index 0000000..a9ae389
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/smallvec-1.8.0/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/socket2-0.4.4/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/socket2-0.4.4/BUILD.bazel
new file mode 100644
index 0000000..028f436
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/socket2-0.4.4/BUILD.bazel
@@ -0,0 +1,119 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "socket2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.4",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+
+            # Common Deps
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/syn-1.0.86/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/syn-1.0.86/BUILD.bazel
new file mode 100644
index 0000000..2a05ffd
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/syn-1.0.86/BUILD.bazel
@@ -0,0 +1,196 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "syn",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+        "visit-mut",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.86",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_pkgs/crates/quote-1.0.15:quote",
+            "//vendor_local_pkgs/crates/syn-1.0.86:build_script_build",
+            "//vendor_local_pkgs/crates/unicode-xid-0.2.2:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "syn_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+        "visit-mut",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.86",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "syn_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sync_wrapper-0.1.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sync_wrapper-0.1.1/BUILD.bazel
new file mode 100644
index 0000000..d3358b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/sync_wrapper-0.1.1/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0
+# ])
+
+rust_library(
+    name = "sync_wrapper",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/thread_local-1.1.4/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/thread_local-1.1.4/BUILD.bazel
new file mode 100644
index 0000000..f77834f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/thread_local-1.1.4/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "thread_local",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/once_cell-1.9.0:once_cell",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-1.16.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-1.16.1/BUILD.bazel
new file mode 100644
index 0000000..559800b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-1.16.1/BUILD.bazel
@@ -0,0 +1,165 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bytes",
+        "default",
+        "fs",
+        "full",
+        "io-std",
+        "io-util",
+        "libc",
+        "macros",
+        "memchr",
+        "mio",
+        "net",
+        "num_cpus",
+        "once_cell",
+        "parking_lot",
+        "process",
+        "rt",
+        "rt-multi-thread",
+        "signal",
+        "signal-hook-registry",
+        "sync",
+        "time",
+        "tokio-macros",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/tokio-macros-1.7.0:tokio_macros",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.16.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/libc-0.2.119:libc",
+            "//vendor_local_pkgs/crates/signal-hook-registry-1.4.0:signal_hook_registry",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/memchr-2.4.1:memchr",
+            "//vendor_local_pkgs/crates/mio-0.7.14:mio",
+            "//vendor_local_pkgs/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_pkgs/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_pkgs/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "//vendor_local_pkgs/crates/winapi-0.3.9:winapi",
+
+            # Common Deps
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/memchr-2.4.1:memchr",
+            "//vendor_local_pkgs/crates/mio-0.7.14:mio",
+            "//vendor_local_pkgs/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_pkgs/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_pkgs/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/memchr-2.4.1:memchr",
+            "//vendor_local_pkgs/crates/mio-0.7.14:mio",
+            "//vendor_local_pkgs/crates/num_cpus-1.13.1:num_cpus",
+            "//vendor_local_pkgs/crates/once_cell-1.9.0:once_cell",
+            "//vendor_local_pkgs/crates/parking_lot-0.11.2:parking_lot",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-macros-1.7.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-macros-1.7.0/BUILD.bazel
new file mode 100644
index 0000000..32e221f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-macros-1.7.0/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tokio_macros",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_pkgs/crates/quote-1.0.15:quote",
+            "//vendor_local_pkgs/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.6.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.6.9/BUILD.bazel
new file mode 100644
index 0000000..379638c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.6.9/BUILD.bazel
@@ -0,0 +1,92 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "codec",
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-sink-0.3.21:futures_sink",
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.7.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.7.0/BUILD.bazel
new file mode 100644
index 0000000..2758f4b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tokio-util-0.7.0/BUILD.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-sink-0.3.21:futures_sink",
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-0.4.12/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-0.4.12/BUILD.bazel
new file mode 100644
index 0000000..36d9127
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-0.4.12/BUILD.bazel
@@ -0,0 +1,106 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "__common",
+        "buffer",
+        "default",
+        "futures-core",
+        "futures-util",
+        "log",
+        "make",
+        "pin-project",
+        "pin-project-lite",
+        "tokio",
+        "tokio-util",
+        "tracing",
+        "util",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/pin-project-1.0.10:pin_project",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/tokio-1.16.1:tokio",
+            "//vendor_local_pkgs/crates/tokio-util-0.7.0:tokio_util",
+            "//vendor_local_pkgs/crates/tower-layer-0.3.1:tower_layer",
+            "//vendor_local_pkgs/crates/tower-service-0.3.1:tower_service",
+            "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-http-0.2.3/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-http-0.2.3/BUILD.bazel
new file mode 100644
index 0000000..4c75db0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-http-0.2.3/BUILD.bazel
@@ -0,0 +1,102 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_http",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "map-response-body",
+        "tower",
+        "trace",
+        "tracing",
+        "util",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/bitflags-1.3.2:bitflags",
+            "//vendor_local_pkgs/crates/bytes-1.1.0:bytes",
+            "//vendor_local_pkgs/crates/futures-core-0.3.21:futures_core",
+            "//vendor_local_pkgs/crates/futures-util-0.3.21:futures_util",
+            "//vendor_local_pkgs/crates/http-0.2.6:http",
+            "//vendor_local_pkgs/crates/http-body-0.4.4:http_body",
+            "//vendor_local_pkgs/crates/http-range-header-0.3.0:http_range_header",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/tower-0.4.12:tower",
+            "//vendor_local_pkgs/crates/tower-layer-0.3.1:tower_layer",
+            "//vendor_local_pkgs/crates/tower-service-0.3.1:tower_service",
+            "//vendor_local_pkgs/crates/tracing-0.1.31:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-layer-0.3.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-layer-0.3.1/BUILD.bazel
new file mode 100644
index 0000000..9e48ea0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-layer-0.3.1/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_layer",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-service-0.3.1/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-service-0.3.1/BUILD.bazel
new file mode 100644
index 0000000..317d496
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tower-service-0.3.1/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_service",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-0.1.31/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-0.1.31/BUILD.bazel
new file mode 100644
index 0000000..069009a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-0.1.31/BUILD.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "attributes",
+        "default",
+        "log",
+        "std",
+        "tracing-attributes",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/tracing-attributes-0.1.19:tracing_attributes",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.31",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/cfg-if-1.0.0:cfg_if",
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+            "//vendor_local_pkgs/crates/pin-project-lite-0.2.8:pin_project_lite",
+            "//vendor_local_pkgs/crates/tracing-core-0.1.22:tracing_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-attributes-0.1.19/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-attributes-0.1.19/BUILD.bazel
new file mode 100644
index 0000000..9ed8663
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-attributes-0.1.19/BUILD.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tracing_attributes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/proc-macro2-1.0.36:proc_macro2",
+            "//vendor_local_pkgs/crates/quote-1.0.15:quote",
+            "//vendor_local_pkgs/crates/syn-1.0.86:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-core-0.1.22/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-core-0.1.22/BUILD.bazel
new file mode 100644
index 0000000..6256b9f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-core-0.1.22/BUILD.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+        "valuable",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.22",
+    deps = [
+    ] + select_with_or({
+        # cfg(tracing_unstable)
+        #
+        # No supported platform triples for cfg: 'cfg(tracing_unstable)'
+        # Skipped dependencies: [{"id":"valuable 0.1.0","target":"valuable"}]
+        #
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/lazy_static-1.4.0:lazy_static",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-log-0.1.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-log-0.1.2/BUILD.bazel
new file mode 100644
index 0000000..3f5ff7d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-log-0.1.2/BUILD.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "log-tracer",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/lazy_static-1.4.0:lazy_static",
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+            "//vendor_local_pkgs/crates/tracing-core-0.1.22:tracing_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-subscriber-0.3.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-subscriber-0.3.9/BUILD.bazel
new file mode 100644
index 0000000..17b127e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/tracing-subscriber-0.3.9/BUILD.bazel
@@ -0,0 +1,101 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_subscriber",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "ansi",
+        "ansi_term",
+        "default",
+        "fmt",
+        "registry",
+        "sharded-slab",
+        "smallvec",
+        "std",
+        "thread_local",
+        "tracing-log",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/ansi_term-0.12.1:ansi_term",
+            "//vendor_local_pkgs/crates/sharded-slab-0.1.4:sharded_slab",
+            "//vendor_local_pkgs/crates/smallvec-1.8.0:smallvec",
+            "//vendor_local_pkgs/crates/thread_local-1.1.4:thread_local",
+            "//vendor_local_pkgs/crates/tracing-core-0.1.22:tracing_core",
+            "//vendor_local_pkgs/crates/tracing-log-0.1.2:tracing_log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/try-lock-0.2.3/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/try-lock-0.2.3/BUILD.bazel
new file mode 100644
index 0000000..10fbaf6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/try-lock-0.2.3/BUILD.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "try_lock",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/unicode-xid-0.2.2/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/unicode-xid-0.2.2/BUILD.bazel
new file mode 100644
index 0000000..30562c1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/unicode-xid-0.2.2/BUILD.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/valuable-0.1.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/valuable-0.1.0/BUILD.bazel
new file mode 100644
index 0000000..e044513
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/valuable-0.1.0/BUILD.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "valuable",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/valuable-0.1.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "valuable_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "valuable_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/want-0.3.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/want-0.3.0/BUILD.bazel
new file mode 100644
index 0000000..9978792
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/want-0.3.0/BUILD.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "want",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/log-0.4.14:log",
+            "//vendor_local_pkgs/crates/try-lock-0.2.3:try_lock",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-0.3.9/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-0.3.9/BUILD.bazel
new file mode 100644
index 0000000..9173bf8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-0.3.9/BUILD.bazel
@@ -0,0 +1,241 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "processenv",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-i686-pc-windows-gnu 0.4.0","target":"winapi_i686_pc_windows_gnu"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-x86_64-pc-windows-gnu 0.4.0","target":"winapi_x86_64_pc_windows_gnu"}]
+        #
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/winapi-0.3.9:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "processenv",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel
new file mode 100644
index 0000000..828411f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-i686-pc-windows-gnu-0.4.0/BUILD.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/winapi-i686-pc-windows-gnu-0.4.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-i686-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-i686-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel
new file mode 100644
index 0000000..8e4afeb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/crates/winapi-x86_64-pc-windows-gnu-0.4.0/BUILD.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "//vendor_local_pkgs/crates/winapi-x86_64-pc-windows-gnu-0.4.0:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-x86_64-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-x86_64-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/src/main.rs b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/src/main.rs
new file mode 100644
index 0000000..edde4b6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_local_pkgs/src/main.rs
@@ -0,0 +1,150 @@
+//! Copied from https://github.com/tokio-rs/axum/blob/v0.2.5/examples/testing/src/main.rs
+
+use axum::{
+    routing::{get, post},
+    Json, Router,
+};
+use tower_http::trace::TraceLayer;
+
+#[tokio::main]
+async fn main() {
+    // Set the RUST_LOG, if it hasn't been explicitly defined
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "example_testing=debug,tower_http=debug")
+    }
+    tracing_subscriber::fmt::init();
+
+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 3000));
+
+    tracing::debug!("listening on {}", addr);
+
+    axum::Server::bind(&addr)
+        .serve(app().into_make_service())
+        .await
+        .unwrap();
+}
+
+/// Having a function that produces our app makes it easy to call it from tests
+/// without having to create an HTTP server.
+#[allow(dead_code)]
+fn app() -> Router {
+    Router::new()
+        .route("/", get(|| async { "Hello, World!" }))
+        .route(
+            "/json",
+            post(|payload: Json<serde_json::Value>| async move {
+                Json(serde_json::json!({ "data": payload.0 }))
+            }),
+        )
+        // We can still add middleware
+        .layer(TraceLayer::new_for_http())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(not(target_os = "windows"))]
+    use std::net::{SocketAddr, TcpListener};
+
+    use axum::{
+        body::Body,
+        http::{self, Request, StatusCode},
+    };
+    use serde_json::{json, Value};
+    use tower::ServiceExt; // for `app.oneshot()`
+
+    #[tokio::test]
+    async fn hello_world() {
+        let app = app();
+
+        // `Router` implements `tower::Service<Request<Body>>` so we can
+        // call it like any tower service, no need to run an HTTP server.
+        let response = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn json() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(http::Method::POST)
+                    .uri("/json")
+                    .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
+                    .body(Body::from(
+                        serde_json::to_vec(&json!([1_i8, 2_i8, 3_i8, 4_i8])).unwrap(),
+                    ))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        let body: Value = serde_json::from_slice(&body).unwrap();
+        assert_eq!(body, json!({ "data": [1_i8, 2_i8, 3_i8, 4_i8] }));
+    }
+
+    #[tokio::test]
+    async fn not_found() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/does-not-exist")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert!(body.is_empty());
+    }
+
+    // TODO: This test fails on Windows, it shouldn't but it's unclear to me
+    // if this is an issue on the host or with the test.
+    #[cfg(not(target_os = "windows"))]
+    // You can also spawn a server and talk to it like any other HTTP server:
+    #[tokio::test]
+    async fn the_real_deal() {
+        let listener = TcpListener::bind("0.0.0.0:0".parse::<SocketAddr>().unwrap()).unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        tokio::spawn(async move {
+            axum::Server::from_tcp(listener)
+                .unwrap()
+                .serve(app().into_make_service())
+                .await
+                .unwrap();
+        });
+
+        let client = hyper::Client::new();
+
+        let response = client
+            .request(
+                Request::builder()
+                    .uri(format!("http://{}", addr))
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/BUILD.bazel
new file mode 100644
index 0000000..a0bad79
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/BUILD.bazel
@@ -0,0 +1,24 @@
+load("@crates_vendor_manifests//:defs.bzl", "aliases", "all_crate_deps")
+load("@rules_rust//crate_universe:defs.bzl", "crates_vendor")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+crates_vendor(
+    name = "crates_vendor_manifests",
+    manifests = [":Cargo.toml"],
+)
+
+rust_library(
+    name = "cargo_local",
+    srcs = glob(["**/*.rs"]),
+    aliases = aliases(),
+    edition = "2018",
+    proc_macro_deps = all_crate_deps(proc_macro = True),
+    deps = all_crate_deps(normal = True),
+)
+
+rust_test(
+    name = "unit_test",
+    crate = ":cargo_local",
+    proc_macro_deps = all_crate_deps(proc_macro_dev = True),
+    deps = all_crate_deps(normal_dev = True),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.lock b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.lock
new file mode 100644
index 0000000..641895b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.lock
@@ -0,0 +1,408 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "async-stream"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "171374e7e3b2504e0e5236e3b59260560f9fe94bfe9ac39ba5e4e929c5590625"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "648ed8c8d2ce5409ccd57453d9d1b214b342a0d69376a6feda1fd6cae3299308"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+
+[[package]]
+name = "cargo_local"
+version = "0.1.0"
+dependencies = [
+ "tempfile",
+ "tokio",
+ "tokio-test",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+
+[[package]]
+name = "lock_api"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "mio"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba272f85fa0b41fc91872be579b3bbe0f56b792aa361a380eb669469f68dafb2"
+dependencies = [
+ "libc",
+ "log",
+ "miow",
+ "ntapi",
+ "winapi",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-sys",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "socket2"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "libc",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "tokio"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af73ac49756f3f7c01172e34a23e5d0216f6c32333757c2c61feb2bbff5a5ee"
+dependencies = [
+ "bytes",
+ "libc",
+ "memchr",
+ "mio",
+ "num_cpus",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "winapi",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50145484efff8818b5ccd256697f36863f587da82cf8b409c53adf1e840798e3"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+dependencies = [
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.toml b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.toml
new file mode 100644
index 0000000..e58d55e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "cargo_local"
+version = "0.1.0"
+authors = ["UebelAndre <github@uebelandre.com>"]
+edition = "2018"
+
+[dependencies]
+tokio = { version = "1.17.0", features = ["full"] }
+
+[dev-dependencies]
+tempfile = "3.2.0"
+tokio-test = "0.4.2"
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-0.3.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-0.3.2.bazel
new file mode 100644
index 0000000..9f22c11
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-0.3.2.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "async_stream",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__async-stream-impl-0.3.2//:async_stream_impl",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__futures-core-0.3.21//:futures_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-impl-0.3.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-impl-0.3.2.bazel
new file mode 100644
index 0000000..e73b1ee
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.async-stream-impl-0.3.2.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "async_stream_impl",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_manifests__quote-1.0.15//:quote",
+            "@crates_vendor_manifests__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bazel
new file mode 100644
index 0000000..0da6951
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bazel
@@ -0,0 +1,47 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+        "crates.bzl",
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+alias(
+    name = "tempfile",
+    actual = "@crates_vendor_manifests__tempfile-3.3.0//:tempfile",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio",
+    actual = "@crates_vendor_manifests__tokio-1.17.0//:tokio",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio-test",
+    actual = "@crates_vendor_manifests__tokio-test-0.4.2//:tokio_test",
+    tags = ["manual"],
+)
+
+# Binaries
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bitflags-1.3.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bitflags-1.3.2.bazel
new file mode 100644
index 0000000..6894746
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bitflags-1.3.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bytes-1.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bytes-1.1.0.bazel
new file mode 100644
index 0000000..b679f2e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.bytes-1.1.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "bytes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..e4aab64
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.fastrand-1.7.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.fastrand-1.7.0.bazel
new file mode 100644
index 0000000..fb44acc
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.fastrand-1.7.0.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "fastrand",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_arch = "wasm32")
+        (
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__instant-0.1.12//:instant",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.futures-core-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.futures-core-0.3.21.bazel
new file mode 100644
index 0000000..18c784f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.futures-core-0.3.21.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__futures-core-0.3.21//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.hermit-abi-0.1.19.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.hermit-abi-0.1.19.bazel
new file mode 100644
index 0000000..02c882d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.hermit-abi-0.1.19.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.instant-0.1.12.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.instant-0.1.12.bazel
new file mode 100644
index 0000000..9bd589e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.instant-0.1.12.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "instant",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.libc-0.2.119.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.libc-0.2.119.bazel
new file mode 100644
index 0000000..0fd8f4d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.libc-0.2.119.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.119",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__libc-0.2.119//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "libc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.119",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "libc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.lock_api-0.4.6.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.lock_api-0.4.6.bazel
new file mode 100644
index 0000000..e7a3f40
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.lock_api-0.4.6.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "lock_api",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__scopeguard-1.1.0//:scopeguard",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.log-0.4.14.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..57df435
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.log-0.4.14.bazel
@@ -0,0 +1,172 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__log-0.4.14//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "log_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "log_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..2dbd77e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "memchr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.4.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__memchr-2.4.1//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "memchr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "memchr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.mio-0.8.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.mio-0.8.0.bazel
new file mode 100644
index 0000000..f5e30fc
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.mio-0.8.0.bazel
@@ -0,0 +1,128 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "mio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "net",
+        "os-ext",
+        "os-poll",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crates_vendor_manifests__log-0.4.14//:log",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__miow-0.3.7//:miow",
+            "@crates_vendor_manifests__ntapi-0.3.7//:ntapi",
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_manifests__log-0.4.14//:log",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_manifests__log-0.4.14//:log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.miow-0.3.7.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.miow-0.3.7.bazel
new file mode 100644
index 0000000..63faa37
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.miow-0.3.7.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "miow",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.ntapi-0.3.7.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.ntapi-0.3.7.bazel
new file mode 100644
index 0000000..a6479c9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.ntapi-0.3.7.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "ntapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__ntapi-0.3.7//:build_script_build",
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "ntapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "ntapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.num_cpus-1.13.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.num_cpus-1.13.1.bazel
new file mode 100644
index 0000000..3586ee5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.num_cpus-1.13.1.bazel
@@ -0,0 +1,116 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.13.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))
+        #
+        # No supported platform triples for cfg: 'cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.once_cell-1.9.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.once_cell-1.9.0.bazel
new file mode 100644
index 0000000..f2a936a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.once_cell-1.9.0.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "once_cell",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "race",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot-0.12.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot-0.12.0.bazel
new file mode 100644
index 0000000..424b7977
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot-0.12.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.12.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__lock_api-0.4.6//:lock_api",
+            "@crates_vendor_manifests__parking_lot_core-0.9.1//:parking_lot_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot_core-0.9.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot_core-0.9.1.bazel
new file mode 100644
index 0000000..fd20e37
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.parking_lot_core-0.9.1.bazel
@@ -0,0 +1,219 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.9.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__parking_lot_core-0.9.1//:build_script_build",
+            "@crates_vendor_manifests__smallvec-1.8.0//:smallvec",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__windows-sys-0.32.0//:windows_sys",
+
+            # Common Deps
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__parking_lot_core-0.9.1//:build_script_build",
+            "@crates_vendor_manifests__smallvec-1.8.0//:smallvec",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__parking_lot_core-0.9.1//:build_script_build",
+            "@crates_vendor_manifests__smallvec-1.8.0//:smallvec",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "parking_lot_core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.9.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "parking_lot_core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.pin-project-lite-0.2.8.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.pin-project-lite-0.2.8.bazel
new file mode 100644
index 0000000..cfd3870
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.pin-project-lite-0.2.8.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project_lite",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.proc-macro2-1.0.36.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.proc-macro2-1.0.36.bazel
new file mode 100644
index 0000000..5485684
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.proc-macro2-1.0.36.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.36",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__proc-macro2-1.0.36//:build_script_build",
+            "@crates_vendor_manifests__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro2_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.36",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro2_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.quote-1.0.15.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.quote-1.0.15.bazel
new file mode 100644
index 0000000..3dc3818
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.quote-1.0.15.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "quote",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__proc-macro2-1.0.36//:proc_macro2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.redox_syscall-0.2.11.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.redox_syscall-0.2.11.bazel
new file mode 100644
index 0000000..590ddd8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.redox_syscall-0.2.11.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "syscall",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__bitflags-1.3.2//:bitflags",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.remove_dir_all-0.5.3.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.remove_dir_all-0.5.3.bazel
new file mode 100644
index 0000000..329b121
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.remove_dir_all-0.5.3.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "remove_dir_all",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.5.3",
+    deps = [
+    ] + select_with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.scopeguard-1.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.scopeguard-1.1.0.bazel
new file mode 100644
index 0000000..0bc1e13
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.scopeguard-1.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.signal-hook-registry-1.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.signal-hook-registry-1.4.0.bazel
new file mode 100644
index 0000000..320e197
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.signal-hook-registry-1.4.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "signal_hook_registry",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.smallvec-1.8.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.smallvec-1.8.0.bazel
new file mode 100644
index 0000000..a9ae389
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.smallvec-1.8.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.socket2-0.4.4.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.socket2-0.4.4.bazel
new file mode 100644
index 0000000..a2283ce
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.socket2-0.4.4.bazel
@@ -0,0 +1,120 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "socket2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "all",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.4",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.syn-1.0.86.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.syn-1.0.86.bazel
new file mode 100644
index 0000000..b4ff6d3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.syn-1.0.86.bazel
@@ -0,0 +1,194 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "syn",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit-mut",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.86",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_manifests__quote-1.0.15//:quote",
+            "@crates_vendor_manifests__syn-1.0.86//:build_script_build",
+            "@crates_vendor_manifests__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "syn_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit-mut",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.86",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "syn_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tempfile-3.3.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tempfile-3.3.0.bazel
new file mode 100644
index 0000000..6e3cacd
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tempfile-3.3.0.bazel
@@ -0,0 +1,134 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "tempfile",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "3.3.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(any(unix, target_os = "wasi"))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__fastrand-1.7.0//:fastrand",
+            "@crates_vendor_manifests__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__fastrand-1.7.0//:fastrand",
+            "@crates_vendor_manifests__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_manifests__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_manifests__fastrand-1.7.0//:fastrand",
+            "@crates_vendor_manifests__remove_dir_all-0.5.3//:remove_dir_all",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-1.17.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-1.17.0.bazel
new file mode 100644
index 0000000..3490657
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-1.17.0.bazel
@@ -0,0 +1,170 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bytes",
+        "default",
+        "fs",
+        "full",
+        "io-std",
+        "io-util",
+        "libc",
+        "macros",
+        "memchr",
+        "mio",
+        "net",
+        "num_cpus",
+        "once_cell",
+        "parking_lot",
+        "process",
+        "rt",
+        "rt-multi-thread",
+        "signal",
+        "signal-hook-registry",
+        "socket2",
+        "sync",
+        "test-util",
+        "time",
+        "tokio-macros",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__tokio-macros-1.7.0//:tokio_macros",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.17.0",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__libc-0.2.119//:libc",
+            "@crates_vendor_manifests__signal-hook-registry-1.4.0//:signal_hook_registry",
+
+            # Common Deps
+            "@crates_vendor_manifests__bytes-1.1.0//:bytes",
+            "@crates_vendor_manifests__memchr-2.4.1//:memchr",
+            "@crates_vendor_manifests__mio-0.8.0//:mio",
+            "@crates_vendor_manifests__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_manifests__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_manifests__parking_lot-0.12.0//:parking_lot",
+            "@crates_vendor_manifests__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_manifests__socket2-0.4.4//:socket2",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_manifests__bytes-1.1.0//:bytes",
+            "@crates_vendor_manifests__memchr-2.4.1//:memchr",
+            "@crates_vendor_manifests__mio-0.8.0//:mio",
+            "@crates_vendor_manifests__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_manifests__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_manifests__parking_lot-0.12.0//:parking_lot",
+            "@crates_vendor_manifests__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_manifests__socket2-0.4.4//:socket2",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_manifests__bytes-1.1.0//:bytes",
+            "@crates_vendor_manifests__memchr-2.4.1//:memchr",
+            "@crates_vendor_manifests__mio-0.8.0//:mio",
+            "@crates_vendor_manifests__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_manifests__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_manifests__parking_lot-0.12.0//:parking_lot",
+            "@crates_vendor_manifests__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_manifests__socket2-0.4.4//:socket2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-macros-1.7.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-macros-1.7.0.bazel
new file mode 100644
index 0000000..b209beb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-macros-1.7.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tokio_macros",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_manifests__quote-1.0.15//:quote",
+            "@crates_vendor_manifests__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-stream-0.1.8.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-stream-0.1.8.bazel
new file mode 100644
index 0000000..ab24cb7
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-stream-0.1.8.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_stream",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "time",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_manifests__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_manifests__tokio-1.17.0//:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-test-0.4.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-test-0.4.2.bazel
new file mode 100644
index 0000000..43f9908
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.tokio-test-0.4.2.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_test",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__async-stream-0.3.2//:async_stream",
+            "@crates_vendor_manifests__bytes-1.1.0//:bytes",
+            "@crates_vendor_manifests__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_manifests__tokio-1.17.0//:tokio",
+            "@crates_vendor_manifests__tokio-stream-0.1.8//:tokio_stream",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..30562c1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..3e20685
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,233 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-i686-pc-windows-gnu 0.4.0","target":"winapi_i686_pc_windows_gnu"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-x86_64-pc-windows-gnu 0.4.0","target":"winapi_x86_64_pc_windows_gnu"}]
+        #
+        "//conditions:default": [
+            "@crates_vendor_manifests__winapi-0.3.9//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..5583f0e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__winapi-i686-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-i686-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-i686-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..612e171
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__winapi-x86_64-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-x86_64-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-x86_64-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows-sys-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows-sys-0.32.0.bazel
new file mode 100644
index 0000000..aea4e85
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows-sys-0.32.0.bazel
@@ -0,0 +1,149 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_sys",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "Win32",
+        "Win32_Foundation",
+        "Win32_System",
+        "Win32_System_LibraryLoader",
+        "Win32_System_SystemServices",
+        "Win32_System_WindowsProgramming",
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        # aarch64-pc-windows-msvc
+        #
+        # No supported platform triples for cfg: 'aarch64-pc-windows-msvc'
+        # Skipped dependencies: [{"id":"windows_aarch64_msvc 0.32.0","target":"windows_aarch64_msvc"}]
+        #
+        # aarch64-uwp-windows-msvc
+        #
+        # No supported platform triples for cfg: 'aarch64-uwp-windows-msvc'
+        # Skipped dependencies: [{"id":"windows_aarch64_msvc 0.32.0","target":"windows_aarch64_msvc"}]
+        #
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"windows_i686_gnu 0.32.0","target":"windows_i686_gnu"}]
+        #
+        # i686-pc-windows-msvc
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__windows_i686_msvc-0.32.0//:windows_i686_msvc",
+
+            # Common Deps
+        ],
+        # i686-uwp-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-uwp-windows-gnu'
+        # Skipped dependencies: [{"id":"windows_i686_gnu 0.32.0","target":"windows_i686_gnu"}]
+        #
+        # i686-uwp-windows-msvc
+        #
+        # No supported platform triples for cfg: 'i686-uwp-windows-msvc'
+        # Skipped dependencies: [{"id":"windows_i686_msvc 0.32.0","target":"windows_i686_msvc"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"windows_x86_64_gnu 0.32.0","target":"windows_x86_64_gnu"}]
+        #
+        # x86_64-pc-windows-msvc
+        (
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_manifests__windows_x86_64_msvc-0.32.0//:windows_x86_64_msvc",
+
+            # Common Deps
+        ],
+        # x86_64-uwp-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-uwp-windows-gnu'
+        # Skipped dependencies: [{"id":"windows_x86_64_gnu 0.32.0","target":"windows_x86_64_gnu"}]
+        #
+        # x86_64-uwp-windows-msvc
+        #
+        # No supported platform triples for cfg: 'x86_64-uwp-windows-msvc'
+        # Skipped dependencies: [{"id":"windows_x86_64_msvc 0.32.0","target":"windows_x86_64_msvc"}]
+        #
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_aarch64_msvc-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_aarch64_msvc-0.32.0.bazel
new file mode 100644
index 0000000..4d430cb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_aarch64_msvc-0.32.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_aarch64_msvc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__windows_aarch64_msvc-0.32.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "windows_aarch64_msvc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.32.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "windows_aarch64_msvc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_gnu-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_gnu-0.32.0.bazel
new file mode 100644
index 0000000..8dfdd56
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_gnu-0.32.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_i686_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__windows_i686_gnu-0.32.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "windows_i686_gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.32.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "windows_i686_gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_msvc-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_msvc-0.32.0.bazel
new file mode 100644
index 0000000..9dff704
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_i686_msvc-0.32.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_i686_msvc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__windows_i686_msvc-0.32.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "windows_i686_msvc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.32.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "windows_i686_msvc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_gnu-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_gnu-0.32.0.bazel
new file mode 100644
index 0000000..d8c50da
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_gnu-0.32.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_x86_64_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__windows_x86_64_gnu-0.32.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "windows_x86_64_gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.32.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "windows_x86_64_gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_msvc-0.32.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_msvc-0.32.0.bazel
new file mode 100644
index 0000000..f0f7b5e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/BUILD.windows_x86_64_msvc-0.32.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "windows_x86_64_msvc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.32.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_manifests__windows_x86_64_msvc-0.32.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "windows_x86_64_msvc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.32.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "windows_x86_64_msvc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/crates.bzl b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/crates.bzl
new file mode 100644
index 0000000..e9fa4c9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/crates.bzl
@@ -0,0 +1,25 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""Rules for defining repositories for remote `crates_vendor` repositories"""
+
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+# buildifier: disable=bzl-visibility
+load("@examples//vendor_remote_manifests/crates:defs.bzl", _crate_repositories = "crate_repositories")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:crates_vendor.bzl", "crates_vendor_remote_repository")
+
+def crate_repositories():
+    maybe(
+        crates_vendor_remote_repository,
+        name = "crates_vendor_manifests",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.bazel"),
+        defs_module = Label("@examples//vendor_remote_manifests/crates:defs.bzl"),
+    )
+
+    _crate_repositories()
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/defs.bzl b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/defs.bzl
new file mode 100644
index 0000000..4e5b7be
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/crates/defs.bzl
@@ -0,0 +1,832 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = None):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+        _COMMON_CONDITION: {
+            "tokio": "@crates_vendor_manifests__tokio-1.17.0//:tokio",
+        },
+    },
+}
+
+_NORMAL_ALIASES = {
+    "vendor_remote_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_NORMAL_DEV_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+        _COMMON_CONDITION: {
+            "tempfile": "@crates_vendor_manifests__tempfile-3.3.0//:tempfile",
+            "tokio-test": "@crates_vendor_manifests__tokio-test-0.4.2//:tokio_test",
+        },
+    },
+}
+
+_NORMAL_DEV_ALIASES = {
+    "vendor_remote_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_PROC_MACRO_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_PROC_MACRO_ALIASES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_PROC_MACRO_DEV_ALIASES = {
+    "vendor_remote_manifests": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_BUILD_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_BUILD_ALIASES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_BUILD_PROC_MACRO_ALIASES = {
+    "vendor_remote_manifests": {
+    },
+}
+
+_CONDITIONS = {
+    "aarch64-pc-windows-msvc": [],
+    "aarch64-uwp-windows-msvc": [],
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(any(unix, target_os = \"wasi\"))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(not(windows))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(target_arch = \"wasm32\")": ["wasm32-unknown-unknown", "wasm32-wasi"],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(unix)": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(windows)": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "i686-pc-windows-gnu": [],
+    "i686-pc-windows-msvc": ["i686-pc-windows-msvc"],
+    "i686-uwp-windows-gnu": [],
+    "i686-uwp-windows-msvc": [],
+    "x86_64-pc-windows-gnu": [],
+    "x86_64-pc-windows-msvc": ["x86_64-pc-windows-msvc"],
+    "x86_64-uwp-windows-gnu": [],
+    "x86_64-uwp-windows-msvc": [],
+}
+
+###############################################################################
+
+def crate_repositories():
+    """A macro for defining repositories for all generated crates"""
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__async-stream-0.3.2",
+        sha256 = "171374e7e3b2504e0e5236e3b59260560f9fe94bfe9ac39ba5e4e929c5590625",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/async-stream/0.3.2/download"],
+        strip_prefix = "async-stream-0.3.2",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.async-stream-0.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__async-stream-impl-0.3.2",
+        sha256 = "648ed8c8d2ce5409ccd57453d9d1b214b342a0d69376a6feda1fd6cae3299308",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/async-stream-impl/0.3.2/download"],
+        strip_prefix = "async-stream-impl-0.3.2",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.async-stream-impl-0.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__bitflags-1.3.2",
+        sha256 = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bitflags/1.3.2/download"],
+        strip_prefix = "bitflags-1.3.2",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.bitflags-1.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__bytes-1.1.0",
+        sha256 = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bytes/1.1.0/download"],
+        strip_prefix = "bytes-1.1.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.bytes-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__cfg-if-1.0.0",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cfg-if/1.0.0/download"],
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__fastrand-1.7.0",
+        sha256 = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fastrand/1.7.0/download"],
+        strip_prefix = "fastrand-1.7.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.fastrand-1.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__futures-core-0.3.21",
+        sha256 = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-core/0.3.21/download"],
+        strip_prefix = "futures-core-0.3.21",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.futures-core-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__hermit-abi-0.1.19",
+        sha256 = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hermit-abi/0.1.19/download"],
+        strip_prefix = "hermit-abi-0.1.19",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.hermit-abi-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__instant-0.1.12",
+        sha256 = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/instant/0.1.12/download"],
+        strip_prefix = "instant-0.1.12",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.instant-0.1.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__libc-0.2.119",
+        sha256 = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/libc/0.2.119/download"],
+        strip_prefix = "libc-0.2.119",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.libc-0.2.119.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__lock_api-0.4.6",
+        sha256 = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/lock_api/0.4.6/download"],
+        strip_prefix = "lock_api-0.4.6",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.lock_api-0.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__log-0.4.14",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/log/0.4.14/download"],
+        strip_prefix = "log-0.4.14",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__memchr-2.4.1",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/memchr/2.4.1/download"],
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__mio-0.8.0",
+        sha256 = "ba272f85fa0b41fc91872be579b3bbe0f56b792aa361a380eb669469f68dafb2",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/mio/0.8.0/download"],
+        strip_prefix = "mio-0.8.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.mio-0.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__miow-0.3.7",
+        sha256 = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/miow/0.3.7/download"],
+        strip_prefix = "miow-0.3.7",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.miow-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__ntapi-0.3.7",
+        sha256 = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ntapi/0.3.7/download"],
+        strip_prefix = "ntapi-0.3.7",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.ntapi-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__num_cpus-1.13.1",
+        sha256 = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num_cpus/1.13.1/download"],
+        strip_prefix = "num_cpus-1.13.1",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.num_cpus-1.13.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__once_cell-1.9.0",
+        sha256 = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/once_cell/1.9.0/download"],
+        strip_prefix = "once_cell-1.9.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.once_cell-1.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__parking_lot-0.12.0",
+        sha256 = "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/parking_lot/0.12.0/download"],
+        strip_prefix = "parking_lot-0.12.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.parking_lot-0.12.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__parking_lot_core-0.9.1",
+        sha256 = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/parking_lot_core/0.9.1/download"],
+        strip_prefix = "parking_lot_core-0.9.1",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.parking_lot_core-0.9.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__pin-project-lite-0.2.8",
+        sha256 = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pin-project-lite/0.2.8/download"],
+        strip_prefix = "pin-project-lite-0.2.8",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.pin-project-lite-0.2.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__proc-macro2-1.0.36",
+        sha256 = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/proc-macro2/1.0.36/download"],
+        strip_prefix = "proc-macro2-1.0.36",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.proc-macro2-1.0.36.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__quote-1.0.15",
+        sha256 = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/quote/1.0.15/download"],
+        strip_prefix = "quote-1.0.15",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.quote-1.0.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__redox_syscall-0.2.11",
+        sha256 = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/redox_syscall/0.2.11/download"],
+        strip_prefix = "redox_syscall-0.2.11",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.redox_syscall-0.2.11.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__remove_dir_all-0.5.3",
+        sha256 = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/remove_dir_all/0.5.3/download"],
+        strip_prefix = "remove_dir_all-0.5.3",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.remove_dir_all-0.5.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__scopeguard-1.1.0",
+        sha256 = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/scopeguard/1.1.0/download"],
+        strip_prefix = "scopeguard-1.1.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.scopeguard-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__signal-hook-registry-1.4.0",
+        sha256 = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/signal-hook-registry/1.4.0/download"],
+        strip_prefix = "signal-hook-registry-1.4.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.signal-hook-registry-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__smallvec-1.8.0",
+        sha256 = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/smallvec/1.8.0/download"],
+        strip_prefix = "smallvec-1.8.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.smallvec-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__socket2-0.4.4",
+        sha256 = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/socket2/0.4.4/download"],
+        strip_prefix = "socket2-0.4.4",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.socket2-0.4.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__syn-1.0.86",
+        sha256 = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/syn/1.0.86/download"],
+        strip_prefix = "syn-1.0.86",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.syn-1.0.86.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__tempfile-3.3.0",
+        sha256 = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tempfile/3.3.0/download"],
+        strip_prefix = "tempfile-3.3.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.tempfile-3.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__tokio-1.17.0",
+        sha256 = "2af73ac49756f3f7c01172e34a23e5d0216f6c32333757c2c61feb2bbff5a5ee",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio/1.17.0/download"],
+        strip_prefix = "tokio-1.17.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.tokio-1.17.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__tokio-macros-1.7.0",
+        sha256 = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-macros/1.7.0/download"],
+        strip_prefix = "tokio-macros-1.7.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.tokio-macros-1.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__tokio-stream-0.1.8",
+        sha256 = "50145484efff8818b5ccd256697f36863f587da82cf8b409c53adf1e840798e3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-stream/0.1.8/download"],
+        strip_prefix = "tokio-stream-0.1.8",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.tokio-stream-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__tokio-test-0.4.2",
+        sha256 = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-test/0.4.2/download"],
+        strip_prefix = "tokio-test-0.4.2",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.tokio-test-0.4.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__unicode-xid-0.2.2",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-xid/0.2.2/download"],
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__winapi-0.3.9",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi/0.3.9/download"],
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__winapi-i686-pc-windows-gnu-0.4.0",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__winapi-x86_64-pc-windows-gnu-0.4.0",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows-sys-0.32.0",
+        sha256 = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows-sys/0.32.0/download"],
+        strip_prefix = "windows-sys-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows-sys-0.32.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows_aarch64_msvc-0.32.0",
+        sha256 = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows_aarch64_msvc/0.32.0/download"],
+        strip_prefix = "windows_aarch64_msvc-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows_aarch64_msvc-0.32.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows_i686_gnu-0.32.0",
+        sha256 = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows_i686_gnu/0.32.0/download"],
+        strip_prefix = "windows_i686_gnu-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows_i686_gnu-0.32.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows_i686_msvc-0.32.0",
+        sha256 = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows_i686_msvc/0.32.0/download"],
+        strip_prefix = "windows_i686_msvc-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows_i686_msvc-0.32.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows_x86_64_gnu-0.32.0",
+        sha256 = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows_x86_64_gnu/0.32.0/download"],
+        strip_prefix = "windows_x86_64_gnu-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows_x86_64_gnu-0.32.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_manifests__windows_x86_64_msvc-0.32.0",
+        sha256 = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/windows_x86_64_msvc/0.32.0/download"],
+        strip_prefix = "windows_x86_64_msvc-0.32.0",
+        build_file = Label("@examples//vendor_remote_manifests/crates:BUILD.windows_x86_64_msvc-0.32.0.bazel"),
+    )
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/src/lib.rs b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/src/lib.rs
new file mode 100644
index 0000000..0e49d04
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_manifests/src/lib.rs
@@ -0,0 +1,44 @@
+use std::path::Path;
+
+use tokio::fs::File;
+use tokio::io::{AsyncBufReadExt, BufReader};
+
+pub async fn fill_buf_file(path: &Path) -> Vec<u8> {
+    let file = File::open(path).await.unwrap();
+    let mut file = BufReader::new(file);
+
+    let mut contents = Vec::new();
+
+    loop {
+        let consumed = {
+            let buffer = file.fill_buf().await.unwrap();
+            if buffer.is_empty() {
+                break;
+            }
+            contents.extend_from_slice(buffer);
+            buffer.len()
+        };
+
+        file.consume(consumed);
+    }
+
+    contents
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use tempfile::NamedTempFile;
+    use tokio_test::assert_ok;
+
+    #[tokio::test]
+    async fn test_fill_buf_file() {
+        let file = NamedTempFile::new().unwrap();
+        assert_ok!(std::fs::write(file.path(), b"hello"));
+
+        let contents = fill_buf_file(file.path()).await;
+
+        assert_eq!(contents, b"hello");
+    }
+}
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/BUILD.bazel
new file mode 100644
index 0000000..387609c
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/BUILD.bazel
@@ -0,0 +1,72 @@
+load("@rules_rust//crate_universe:defs.bzl", "crate", "crates_vendor")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
+
+crates_vendor(
+    name = "crates_vendor_pkgs",
+    annotations = {
+        "axum": [crate.annotation(
+            compile_data_glob = ["**/*.md"],
+        )],
+    },
+    mode = "remote",
+    packages = {
+        "axum": crate.spec(
+            version = "0.4.0",
+        ),
+        "hyper": crate.spec(
+            features = ["full"],
+            version = "0.14",
+        ),
+        "mime": crate.spec(
+            version = "0.3",
+        ),
+        "serde_json": crate.spec(
+            version = "1.0",
+        ),
+        # TODO: This is pinned due to a build failure introduced by 1.17
+        # bringing in windows-sys and introduces linker errors.
+        # https://github.com/abrisco/cargo-bazel/issues/173
+        "tokio": crate.spec(
+            features = ["full"],
+            version = "=1.16.1",
+        ),
+        "tower": crate.spec(
+            features = ["util"],
+            version = "0.4",
+        ),
+        "tower-http": crate.spec(
+            features = ["trace"],
+            version = "0.2.1",
+        ),
+        "tracing": crate.spec(
+            version = "0.1",
+        ),
+        "tracing-subscriber": crate.spec(
+            version = "0.3",
+        ),
+    },
+)
+
+rust_binary(
+    name = "vendor_remote",
+    srcs = glob(["**/*.rs"]),
+    edition = "2018",
+    deps = [
+        "@crates_vendor_pkgs//:axum",
+        "@crates_vendor_pkgs//:hyper",
+        "@crates_vendor_pkgs//:mime",
+        "@crates_vendor_pkgs//:serde_json",
+        "@crates_vendor_pkgs//:tokio",
+        "@crates_vendor_pkgs//:tower",
+        "@crates_vendor_pkgs//:tower-http",
+        "@crates_vendor_pkgs//:tracing",
+        "@crates_vendor_pkgs//:tracing-subscriber",
+    ],
+)
+
+rust_test(
+    name = "unit_test",
+    srcs = glob(["**/*.rs"]),
+    crate = ":vendor_remote",
+    edition = "2018",
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ansi_term-0.12.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ansi_term-0.12.1.bazel
new file mode 100644
index 0000000..3e1dbce
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ansi_term-0.12.1.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "ansi_term",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.12.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "windows")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.async-trait-0.1.52.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.async-trait-0.1.52.bazel
new file mode 100644
index 0000000..b58cec9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.async-trait-0.1.52.bazel
@@ -0,0 +1,174 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_proc_macro(
+    name = "async_trait",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.52",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__async-trait-0.1.52//:build_script_build",
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_pkgs__quote-1.0.15//:quote",
+            "@crates_vendor_pkgs__syn-1.0.86//:syn",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "async-trait_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.52",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "async-trait_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.autocfg-1.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.autocfg-1.1.0.bazel
new file mode 100644
index 0000000..bd2fcd9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.autocfg-1.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-0.4.8.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-0.4.8.bazel
new file mode 100644
index 0000000..5becb06
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-0.4.8.bazel
@@ -0,0 +1,114 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "axum",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob([
+        "**",
+        "**/*.md",
+    ]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "http1",
+        "json",
+        "serde_json",
+        "tower-log",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__async-trait-0.1.52//:async_trait",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__axum-core-0.1.2//:axum_core",
+            "@crates_vendor_pkgs__bitflags-1.3.2//:bitflags",
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__http-body-0.4.4//:http_body",
+            "@crates_vendor_pkgs__hyper-0.14.17//:hyper",
+            "@crates_vendor_pkgs__matchit-0.4.6//:matchit",
+            "@crates_vendor_pkgs__memchr-2.4.1//:memchr",
+            "@crates_vendor_pkgs__mime-0.3.16//:mime",
+            "@crates_vendor_pkgs__percent-encoding-2.1.0//:percent_encoding",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__serde-1.0.136//:serde",
+            "@crates_vendor_pkgs__serde_json-1.0.79//:serde_json",
+            "@crates_vendor_pkgs__serde_urlencoded-0.7.1//:serde_urlencoded",
+            "@crates_vendor_pkgs__sync_wrapper-0.1.1//:sync_wrapper",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+            "@crates_vendor_pkgs__tower-0.4.12//:tower",
+            "@crates_vendor_pkgs__tower-http-0.2.3//:tower_http",
+            "@crates_vendor_pkgs__tower-layer-0.3.1//:tower_layer",
+            "@crates_vendor_pkgs__tower-service-0.3.1//:tower_service",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-core-0.1.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-core-0.1.2.bazel
new file mode 100644
index 0000000..60eff32
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.axum-core-0.1.2.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "axum_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__async-trait-0.1.52//:async_trait",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__http-body-0.4.4//:http_body",
+            "@crates_vendor_pkgs__mime-0.3.16//:mime",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bazel
new file mode 100644
index 0000000..8c3bd31
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bazel
@@ -0,0 +1,83 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(
+    [
+        "cargo-bazel.json",
+        "defs.bzl",
+        "crates.bzl",
+    ] + glob([
+        "*.bazel",
+    ]),
+)
+
+filegroup(
+    name = "srcs",
+    srcs = glob([
+        "*.bazel",
+        "*.bzl",
+    ]),
+)
+
+# Workspace Member Dependencies
+alias(
+    name = "axum",
+    actual = "@crates_vendor_pkgs__axum-0.4.8//:axum",
+    tags = ["manual"],
+)
+
+alias(
+    name = "hyper",
+    actual = "@crates_vendor_pkgs__hyper-0.14.17//:hyper",
+    tags = ["manual"],
+)
+
+alias(
+    name = "mime",
+    actual = "@crates_vendor_pkgs__mime-0.3.16//:mime",
+    tags = ["manual"],
+)
+
+alias(
+    name = "serde_json",
+    actual = "@crates_vendor_pkgs__serde_json-1.0.79//:serde_json",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tokio",
+    actual = "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tower",
+    actual = "@crates_vendor_pkgs__tower-0.4.12//:tower",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tower-http",
+    actual = "@crates_vendor_pkgs__tower-http-0.2.3//:tower_http",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tracing",
+    actual = "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+    tags = ["manual"],
+)
+
+alias(
+    name = "tracing-subscriber",
+    actual = "@crates_vendor_pkgs__tracing-subscriber-0.3.9//:tracing_subscriber",
+    tags = ["manual"],
+)
+
+# Binaries
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bitflags-1.3.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bitflags-1.3.2.bazel
new file mode 100644
index 0000000..6894746
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bitflags-1.3.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.3.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bytes-1.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bytes-1.1.0.bazel
new file mode 100644
index 0000000..b679f2e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.bytes-1.1.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "bytes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..e4aab64
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.fnv-1.0.7.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.fnv-1.0.7.bazel
new file mode 100644
index 0000000..9b3c6e3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.fnv-1.0.7.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 / MIT
+# ])
+
+rust_library(
+    name = "fnv",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.form_urlencoded-1.0.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.form_urlencoded-1.0.1.bazel
new file mode 100644
index 0000000..bd48fd1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.form_urlencoded-1.0.1.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "form_urlencoded",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__matches-0.1.9//:matches",
+            "@crates_vendor_pkgs__percent-encoding-2.1.0//:percent_encoding",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-channel-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-channel-0.3.21.bazel
new file mode 100644
index 0000000..2b9d729
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-channel-0.3.21.bazel
@@ -0,0 +1,178 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_channel",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__futures-channel-0.3.21//:build_script_build",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-channel_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-channel_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-core-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-core-0.3.21.bazel
new file mode 100644
index 0000000..8d8e0cf
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-core-0.3.21.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__futures-core-0.3.21//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-sink-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-sink-0.3.21.bazel
new file mode 100644
index 0000000..cbdd96f
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-sink-0.3.21.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_sink",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-task-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-task-0.3.21.bazel
new file mode 100644
index 0000000..0c6da9d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-task-0.3.21.bazel
@@ -0,0 +1,173 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_task",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__futures-task-0.3.21//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-task_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-task_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-util-0.3.21.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-util-0.3.21.bazel
new file mode 100644
index 0000000..0645b60
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.futures-util-0.3.21.bazel
@@ -0,0 +1,177 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "futures_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.21",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-task-0.3.21//:futures_task",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:build_script_build",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__pin-utils-0.1.0//:pin_utils",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "futures-util_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.21",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "futures-util_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.h2-0.3.11.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.h2-0.3.11.bazel
new file mode 100644
index 0000000..0e2689d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.h2-0.3.11.bazel
@@ -0,0 +1,95 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "h2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__fnv-1.0.7//:fnv",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-sink-0.3.21//:futures_sink",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__indexmap-1.8.0//:indexmap",
+            "@crates_vendor_pkgs__slab-0.4.5//:slab",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+            "@crates_vendor_pkgs__tokio-util-0.6.9//:tokio_util",
+            "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hashbrown-0.11.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hashbrown-0.11.2.bazel
new file mode 100644
index 0000000..54a071b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hashbrown-0.11.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "hashbrown",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "raw",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hermit-abi-0.1.19.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hermit-abi-0.1.19.bazel
new file mode 100644
index 0000000..c59daf3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hermit-abi-0.1.19.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-0.2.6.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-0.2.6.bazel
new file mode 100644
index 0000000..e72665d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-0.2.6.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "http",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__fnv-1.0.7//:fnv",
+            "@crates_vendor_pkgs__itoa-1.0.1//:itoa",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-body-0.4.4.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-body-0.4.4.bazel
new file mode 100644
index 0000000..d85585b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-body-0.4.4.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "http_body",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-range-header-0.3.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-range-header-0.3.0.bazel
new file mode 100644
index 0000000..c2d71d8
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.http-range-header-0.3.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "http_range_header",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httparse-1.6.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httparse-1.6.0.bazel
new file mode 100644
index 0000000..c28f5d5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httparse-1.6.0.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "httparse",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.6.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__httparse-1.6.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "httparse_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.6.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "httparse_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httpdate-1.0.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httpdate-1.0.2.bazel
new file mode 100644
index 0000000..16d4a28
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.httpdate-1.0.2.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "httpdate",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hyper-0.14.17.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hyper-0.14.17.bazel
new file mode 100644
index 0000000..ee4bdb4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.hyper-0.14.17.bazel
@@ -0,0 +1,111 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "hyper",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "client",
+        "default",
+        "full",
+        "h2",
+        "http1",
+        "http2",
+        "runtime",
+        "server",
+        "socket2",
+        "stream",
+        "tcp",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.14.17",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-channel-0.3.21//:futures_channel",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__h2-0.3.11//:h2",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__http-body-0.4.4//:http_body",
+            "@crates_vendor_pkgs__httparse-1.6.0//:httparse",
+            "@crates_vendor_pkgs__httpdate-1.0.2//:httpdate",
+            "@crates_vendor_pkgs__itoa-1.0.1//:itoa",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__socket2-0.4.4//:socket2",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+            "@crates_vendor_pkgs__tower-service-0.3.1//:tower_service",
+            "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+            "@crates_vendor_pkgs__want-0.3.0//:want",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.indexmap-1.8.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.indexmap-1.8.0.bazel
new file mode 100644
index 0000000..6989baf
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.indexmap-1.8.0.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "indexmap",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__hashbrown-0.11.2//:hashbrown",
+            "@crates_vendor_pkgs__indexmap-1.8.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "indexmap_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.8.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__autocfg-1.1.0//:autocfg",
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "indexmap_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.instant-0.1.12.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.instant-0.1.12.bazel
new file mode 100644
index 0000000..024232d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.instant-0.1.12.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # BSD-3-Clause
+# ])
+
+rust_library(
+    name = "instant",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.itoa-1.0.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.itoa-1.0.1.bazel
new file mode 100644
index 0000000..69bfcf9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.itoa-1.0.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "itoa",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..aabde66
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.libc-0.2.119.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.libc-0.2.119.bazel
new file mode 100644
index 0000000..139c214
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.libc-0.2.119.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "libc",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.119",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__libc-0.2.119//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "libc_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.2.119",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "libc_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lock_api-0.4.6.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lock_api-0.4.6.bazel
new file mode 100644
index 0000000..3c36221
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.lock_api-0.4.6.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "lock_api",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__scopeguard-1.1.0//:scopeguard",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.log-0.4.14.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..e63b9d0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.log-0.4.14.bazel
@@ -0,0 +1,174 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.14",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_pkgs__log-0.4.14//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "log_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "log_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matches-0.1.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matches-0.1.9.bazel
new file mode 100644
index 0000000..b2ec92b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matches-0.1.9.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "matches",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matchit-0.4.6.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matchit-0.4.6.bazel
new file mode 100644
index 0000000..dd3406b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.matchit-0.4.6.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "matchit",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.6",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..c1d16f6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Unlicense/MIT
+# ])
+
+rust_library(
+    name = "memchr",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.4.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__memchr-2.4.1//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "memchr_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "memchr_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mime-0.3.16.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mime-0.3.16.bazel
new file mode 100644
index 0000000..d7f8128
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mime-0.3.16.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "mime",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.16",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mio-0.7.14.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mio-0.7.14.bazel
new file mode 100644
index 0000000..f439769
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.mio-0.7.14.bazel
@@ -0,0 +1,132 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "mio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "net",
+        "os-ext",
+        "os-poll",
+        "os-util",
+        "tcp",
+        "udp",
+        "uds",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.14",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__miow-0.3.7//:miow",
+            "@crates_vendor_pkgs__ntapi-0.3.7//:ntapi",
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.miow-0.3.7.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.miow-0.3.7.bazel
new file mode 100644
index 0000000..3934129
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.miow-0.3.7.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "miow",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ntapi-0.3.7.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ntapi-0.3.7.bazel
new file mode 100644
index 0000000..533a620
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ntapi-0.3.7.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "ntapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.7",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__ntapi-0.3.7//:build_script_build",
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "ntapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "user",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.7",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "ntapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.num_cpus-1.13.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.num_cpus-1.13.1.bazel
new file mode 100644
index 0000000..95eca12
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.num_cpus-1.13.1.bazel
@@ -0,0 +1,116 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.13.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))
+        #
+        # No supported platform triples for cfg: 'cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))'
+        # Skipped dependencies: [{"id":"hermit-abi 0.1.19","target":"hermit_abi"}]
+        #
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.once_cell-1.9.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.once_cell-1.9.0.bazel
new file mode 100644
index 0000000..f2a936a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.once_cell-1.9.0.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "once_cell",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "default",
+        "race",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.9.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot-0.11.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot-0.11.2.bazel
new file mode 100644
index 0000000..f630b0e
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot-0.11.2.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.11.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__instant-0.1.12//:instant",
+            "@crates_vendor_pkgs__lock_api-0.4.6//:lock_api",
+            "@crates_vendor_pkgs__parking_lot_core-0.8.5//:parking_lot_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot_core-0.8.5.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot_core-0.8.5.bazel
new file mode 100644
index 0000000..2f0ece6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.parking_lot_core-0.8.5.bazel
@@ -0,0 +1,222 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "parking_lot_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.8.5",
+    deps = [
+    ] + select_with_or({
+        # cfg(target_os = "redox")
+        #
+        # No supported platform triples for cfg: 'cfg(target_os = "redox")'
+        # Skipped dependencies: [{"id":"redox_syscall 0.2.11","target":"syscall"}]
+        #
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+
+            # Common Deps
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_pkgs__instant-0.1.12//:instant",
+            "@crates_vendor_pkgs__parking_lot_core-0.8.5//:build_script_build",
+            "@crates_vendor_pkgs__smallvec-1.8.0//:smallvec",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_pkgs__instant-0.1.12//:instant",
+            "@crates_vendor_pkgs__parking_lot_core-0.8.5//:build_script_build",
+            "@crates_vendor_pkgs__smallvec-1.8.0//:smallvec",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_pkgs__instant-0.1.12//:instant",
+            "@crates_vendor_pkgs__parking_lot_core-0.8.5//:build_script_build",
+            "@crates_vendor_pkgs__smallvec-1.8.0//:smallvec",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "parking_lot_core_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.8.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "parking_lot_core_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.percent-encoding-2.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.percent-encoding-2.1.0.bazel
new file mode 100644
index 0000000..1ad467a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.percent-encoding-2.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "percent_encoding",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "2.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-1.0.10.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-1.0.10.bazel
new file mode 100644
index 0000000..dace729
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-1.0.10.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__pin-project-internal-1.0.10//:pin_project_internal",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.10",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-internal-1.0.10.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-internal-1.0.10.bazel
new file mode 100644
index 0000000..be8b0c9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-internal-1.0.10.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_proc_macro(
+    name = "pin_project_internal",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.10",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_pkgs__quote-1.0.15//:quote",
+            "@crates_vendor_pkgs__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-lite-0.2.8.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-lite-0.2.8.bazel
new file mode 100644
index 0000000..cfd3870
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-project-lite-0.2.8.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR MIT
+# ])
+
+rust_library(
+    name = "pin_project_lite",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.8",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-utils-0.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-utils-0.1.0.bazel
new file mode 100644
index 0000000..de4c1a2
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.pin-utils-0.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "pin_utils",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.proc-macro2-1.0.36.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.proc-macro2-1.0.36.bazel
new file mode 100644
index 0000000..6318a86
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.proc-macro2-1.0.36.bazel
@@ -0,0 +1,176 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.36",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:build_script_build",
+            "@crates_vendor_pkgs__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "proc-macro2_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.36",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "proc-macro2_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.quote-1.0.15.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.quote-1.0.15.bazel
new file mode 100644
index 0000000..bad70cc
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.quote-1.0.15.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "quote",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.15",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.redox_syscall-0.2.11.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.redox_syscall-0.2.11.bazel
new file mode 100644
index 0000000..f001325
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.redox_syscall-0.2.11.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "syscall",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.11",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bitflags-1.3.2//:bitflags",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ryu-1.0.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ryu-1.0.9.bazel
new file mode 100644
index 0000000..c2a9c81
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.ryu-1.0.9.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0 OR BSL-1.0
+# ])
+
+rust_library(
+    name = "ryu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.scopeguard-1.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.scopeguard-1.1.0.bazel
new file mode 100644
index 0000000..0bc1e13
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.scopeguard-1.1.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde-1.0.136.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde-1.0.136.bazel
new file mode 100644
index 0000000..b2b5369
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde-1.0.136.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.136",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__serde-1.0.136//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.136",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_json-1.0.79.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_json-1.0.79.bazel
new file mode 100644
index 0000000..e827016
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_json-1.0.79.bazel
@@ -0,0 +1,180 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "serde_json",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "raw_value",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.79",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__itoa-1.0.1//:itoa",
+            "@crates_vendor_pkgs__ryu-1.0.9//:ryu",
+            "@crates_vendor_pkgs__serde-1.0.136//:serde",
+            "@crates_vendor_pkgs__serde_json-1.0.79//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "serde_json_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "raw_value",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.79",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "serde_json_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_urlencoded-0.7.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_urlencoded-0.7.1.bazel
new file mode 100644
index 0000000..a0618b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.serde_urlencoded-0.7.1.bazel
@@ -0,0 +1,88 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "serde_urlencoded",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__form_urlencoded-1.0.1//:form_urlencoded",
+            "@crates_vendor_pkgs__itoa-1.0.1//:itoa",
+            "@crates_vendor_pkgs__ryu-1.0.9//:ryu",
+            "@crates_vendor_pkgs__serde-1.0.136//:serde",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sharded-slab-0.1.4.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sharded-slab-0.1.4.bazel
new file mode 100644
index 0000000..cfcc376
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sharded-slab-0.1.4.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "sharded_slab",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__lazy_static-1.4.0//:lazy_static",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.signal-hook-registry-1.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.signal-hook-registry-1.4.0.bazel
new file mode 100644
index 0000000..1bfc0da
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.signal-hook-registry-1.4.0.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "signal_hook_registry",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.slab-0.4.5.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.slab-0.4.5.bazel
new file mode 100644
index 0000000..d4303ef
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.slab-0.4.5.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "slab",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.5",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.smallvec-1.8.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.smallvec-1.8.0.bazel
new file mode 100644
index 0000000..a9ae389
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.smallvec-1.8.0.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.8.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.socket2-0.4.4.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.socket2-0.4.4.bazel
new file mode 100644
index 0000000..f9ccd49
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.socket2-0.4.4.bazel
@@ -0,0 +1,119 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "socket2",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.4",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+
+            # Common Deps
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+
+            # Common Deps
+        ],
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.syn-1.0.86.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.syn-1.0.86.bazel
new file mode 100644
index 0000000..5653b39
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.syn-1.0.86.bazel
@@ -0,0 +1,196 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "syn",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+        "visit-mut",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.0.86",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_pkgs__quote-1.0.15//:quote",
+            "@crates_vendor_pkgs__syn-1.0.86//:build_script_build",
+            "@crates_vendor_pkgs__unicode-xid-0.2.2//:unicode_xid",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "syn_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+        "visit-mut",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "1.0.86",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "syn_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sync_wrapper-0.1.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sync_wrapper-0.1.1.bazel
new file mode 100644
index 0000000..d3358b4
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.sync_wrapper-0.1.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0
+# ])
+
+rust_library(
+    name = "sync_wrapper",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.thread_local-1.1.4.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.thread_local-1.1.4.bazel
new file mode 100644
index 0000000..68b0305
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.thread_local-1.1.4.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # Apache-2.0/MIT
+# ])
+
+rust_library(
+    name = "thread_local",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.1.4",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__once_cell-1.9.0//:once_cell",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-1.16.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-1.16.1.bazel
new file mode 100644
index 0000000..35237a9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-1.16.1.bazel
@@ -0,0 +1,165 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "bytes",
+        "default",
+        "fs",
+        "full",
+        "io-std",
+        "io-util",
+        "libc",
+        "macros",
+        "memchr",
+        "mio",
+        "net",
+        "num_cpus",
+        "once_cell",
+        "parking_lot",
+        "process",
+        "rt",
+        "rt-multi-thread",
+        "signal",
+        "signal-hook-registry",
+        "sync",
+        "time",
+        "tokio-macros",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__tokio-macros-1.7.0//:tokio_macros",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.16.1",
+    deps = [
+    ] + select_with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:armv7-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__libc-0.2.119//:libc",
+            "@crates_vendor_pkgs__signal-hook-registry-1.4.0//:signal_hook_registry",
+
+            # Common Deps
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__memchr-2.4.1//:memchr",
+            "@crates_vendor_pkgs__mio-0.7.14//:mio",
+            "@crates_vendor_pkgs__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_pkgs__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_pkgs__parking_lot-0.11.2//:parking_lot",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+        ],
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            # Target Deps
+            "@crates_vendor_pkgs__winapi-0.3.9//:winapi",
+
+            # Common Deps
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__memchr-2.4.1//:memchr",
+            "@crates_vendor_pkgs__mio-0.7.14//:mio",
+            "@crates_vendor_pkgs__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_pkgs__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_pkgs__parking_lot-0.11.2//:parking_lot",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+        ],
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__memchr-2.4.1//:memchr",
+            "@crates_vendor_pkgs__mio-0.7.14//:mio",
+            "@crates_vendor_pkgs__num_cpus-1.13.1//:num_cpus",
+            "@crates_vendor_pkgs__once_cell-1.9.0//:once_cell",
+            "@crates_vendor_pkgs__parking_lot-0.11.2//:parking_lot",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-macros-1.7.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-macros-1.7.0.bazel
new file mode 100644
index 0000000..fee514a
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-macros-1.7.0.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tokio_macros",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "1.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_pkgs__quote-1.0.15//:quote",
+            "@crates_vendor_pkgs__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.6.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.6.9.bazel
new file mode 100644
index 0000000..7d8b271
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.6.9.bazel
@@ -0,0 +1,92 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "codec",
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.6.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-sink-0.3.21//:futures_sink",
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.7.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.7.0.bazel
new file mode 100644
index 0000000..7cb6846
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tokio-util-0.7.0.bazel
@@ -0,0 +1,90 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tokio_util",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.7.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-sink-0.3.21//:futures_sink",
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-0.4.12.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-0.4.12.bazel
new file mode 100644
index 0000000..7acabc6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-0.4.12.bazel
@@ -0,0 +1,106 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "__common",
+        "buffer",
+        "default",
+        "futures-core",
+        "futures-util",
+        "log",
+        "make",
+        "pin-project",
+        "pin-project-lite",
+        "tokio",
+        "tokio-util",
+        "tracing",
+        "util",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.12",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__pin-project-1.0.10//:pin_project",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+            "@crates_vendor_pkgs__tokio-util-0.7.0//:tokio_util",
+            "@crates_vendor_pkgs__tower-layer-0.3.1//:tower_layer",
+            "@crates_vendor_pkgs__tower-service-0.3.1//:tower_service",
+            "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-http-0.2.3.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-http-0.2.3.bazel
new file mode 100644
index 0000000..fed12a5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-http-0.2.3.bazel
@@ -0,0 +1,102 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_http",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "map-response-body",
+        "tower",
+        "trace",
+        "tracing",
+        "util",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__bitflags-1.3.2//:bitflags",
+            "@crates_vendor_pkgs__bytes-1.1.0//:bytes",
+            "@crates_vendor_pkgs__futures-core-0.3.21//:futures_core",
+            "@crates_vendor_pkgs__futures-util-0.3.21//:futures_util",
+            "@crates_vendor_pkgs__http-0.2.6//:http",
+            "@crates_vendor_pkgs__http-body-0.4.4//:http_body",
+            "@crates_vendor_pkgs__http-range-header-0.3.0//:http_range_header",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__tower-0.4.12//:tower",
+            "@crates_vendor_pkgs__tower-layer-0.3.1//:tower_layer",
+            "@crates_vendor_pkgs__tower-service-0.3.1//:tower_service",
+            "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-layer-0.3.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-layer-0.3.1.bazel
new file mode 100644
index 0000000..9e48ea0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-layer-0.3.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_layer",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-service-0.3.1.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-service-0.3.1.bazel
new file mode 100644
index 0000000..317d496
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tower-service-0.3.1.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tower_service",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.1",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-0.1.31.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-0.1.31.bazel
new file mode 100644
index 0000000..4b7cbd3
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-0.1.31.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "attributes",
+        "default",
+        "log",
+        "std",
+        "tracing-attributes",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__tracing-attributes-0.1.19//:tracing_attributes",
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.31",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__cfg-if-1.0.0//:cfg_if",
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+            "@crates_vendor_pkgs__pin-project-lite-0.2.8//:pin_project_lite",
+            "@crates_vendor_pkgs__tracing-core-0.1.22//:tracing_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-attributes-0.1.19.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-attributes-0.1.19.bazel
new file mode 100644
index 0000000..fe555bb
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-attributes-0.1.19.bazel
@@ -0,0 +1,87 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_proc_macro",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_proc_macro(
+    name = "tracing_attributes",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.19",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__proc-macro2-1.0.36//:proc_macro2",
+            "@crates_vendor_pkgs__quote-1.0.15//:quote",
+            "@crates_vendor_pkgs__syn-1.0.86//:syn",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-core-0.1.22.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-core-0.1.22.bazel
new file mode 100644
index 0000000..8dd06ff
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-core-0.1.22.bazel
@@ -0,0 +1,94 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_core",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+        "valuable",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.22",
+    deps = [
+    ] + select_with_or({
+        # cfg(tracing_unstable)
+        #
+        # No supported platform triples for cfg: 'cfg(tracing_unstable)'
+        # Skipped dependencies: [{"id":"valuable 0.1.0","target":"valuable"}]
+        #
+        "//conditions:default": [
+            "@crates_vendor_pkgs__lazy_static-1.4.0//:lazy_static",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-log-0.1.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-log-0.1.2.bazel
new file mode 100644
index 0000000..a516069
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-log-0.1.2.bazel
@@ -0,0 +1,89 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_log",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "log-tracer",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__lazy_static-1.4.0//:lazy_static",
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+            "@crates_vendor_pkgs__tracing-core-0.1.22//:tracing_core",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-subscriber-0.3.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-subscriber-0.3.9.bazel
new file mode 100644
index 0000000..6555328
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.tracing-subscriber-0.3.9.bazel
@@ -0,0 +1,101 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "tracing_subscriber",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "ansi",
+        "ansi_term",
+        "default",
+        "fmt",
+        "registry",
+        "sharded-slab",
+        "smallvec",
+        "std",
+        "thread_local",
+        "tracing-log",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__ansi_term-0.12.1//:ansi_term",
+            "@crates_vendor_pkgs__sharded-slab-0.1.4//:sharded_slab",
+            "@crates_vendor_pkgs__smallvec-1.8.0//:smallvec",
+            "@crates_vendor_pkgs__thread_local-1.1.4//:thread_local",
+            "@crates_vendor_pkgs__tracing-core-0.1.22//:tracing_core",
+            "@crates_vendor_pkgs__tracing-log-0.1.2//:tracing_log",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.try-lock-0.2.3.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.try-lock-0.2.3.bazel
new file mode 100644
index 0000000..10fbaf6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.try-lock-0.2.3.bazel
@@ -0,0 +1,84 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "try_lock",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.3",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..30562c1
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,85 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT OR Apache-2.0
+# ])
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.2.2",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.valuable-0.1.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.valuable-0.1.0.bazel
new file mode 100644
index 0000000..9bd0d0b
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.valuable-0.1.0.bazel
@@ -0,0 +1,175 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "valuable",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.1.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__valuable-0.1.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "valuable_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "alloc",
+        "std",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.1.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "valuable_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.want-0.3.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.want-0.3.0.bazel
new file mode 100644
index 0000000..d13a311
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.want-0.3.0.bazel
@@ -0,0 +1,86 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT
+# ])
+
+rust_library(
+    name = "want",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2018",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__log-0.4.14//:log",
+            "@crates_vendor_pkgs__try-lock-0.2.3//:try_lock",
+        ],
+    }),
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..f50047d
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,241 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "processenv",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.3.9",
+    deps = [
+    ] + select_with_or({
+        # i686-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'i686-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-i686-pc-windows-gnu 0.4.0","target":"winapi_i686_pc_windows_gnu"}]
+        #
+        # x86_64-pc-windows-gnu
+        #
+        # No supported platform triples for cfg: 'x86_64-pc-windows-gnu'
+        # Skipped dependencies: [{"id":"winapi-x86_64-pc-windows-gnu 0.4.0","target":"winapi_x86_64_pc_windows_gnu"}]
+        #
+        "//conditions:default": [
+            "@crates_vendor_pkgs__winapi-0.3.9//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+        "cfg",
+        "consoleapi",
+        "errhandlingapi",
+        "evntrace",
+        "fileapi",
+        "handleapi",
+        "in6addr",
+        "inaddr",
+        "ioapiset",
+        "minwinbase",
+        "minwindef",
+        "mstcpip",
+        "mswsock",
+        "namedpipeapi",
+        "ntdef",
+        "ntsecapi",
+        "ntstatus",
+        "processenv",
+        "std",
+        "synchapi",
+        "threadpoollegacyapiset",
+        "winbase",
+        "windef",
+        "winerror",
+        "winioctl",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..ec8ffa9
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__winapi-i686-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-i686-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-i686-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..0ce2e90
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,171 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+
+load(
+    "@bazel_skylib//lib:selects.bzl",
+    "selects",
+)
+load(
+    "@rules_rust//cargo:defs.bzl",
+    "cargo_build_script",
+)
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:selects.bzl", "select_with_or")
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+# licenses([
+#     "TODO",  # MIT/Apache-2.0
+# ])
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    compile_data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    version = "0.4.0",
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+            "@crates_vendor_pkgs__winapi-x86_64-pc-windows-gnu-0.4.0//:build_script_build",
+        ],
+    }),
+)
+
+cargo_build_script(
+    # See comment associated with alias. Do not change this name
+    name = "winapi-x86_64-pc-windows-gnu_build_script",
+    srcs = glob(
+        include = [
+            "**/*.rs",
+        ],
+        exclude = [
+        ],
+    ),
+    aliases = selects.with_or({
+        "//conditions:default": {
+        },
+    }),
+    build_script_env = {
+    },
+    compile_data = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    crate_features = [
+    ],
+    crate_name = "build_script_build",
+    crate_root = "build.rs",
+    data = glob(["**"]) + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    edition = "2015",
+    proc_macro_deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_env = {
+    },
+    rustc_env_files = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    rustc_flags = [
+        # In most cases, warnings in 3rd party crates are not interesting as
+        # they're out of the control of consumers. The flag here silences
+        # warnings. For more details see:
+        # https://doc.rust-lang.org/rustc/lints/levels.html
+        "--cap-lints=allow",
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    tags = [
+        "cargo-bazel",
+        "manual",
+        "noclippy",
+        "norustfmt",
+    ],
+    tools = select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ] + select_with_or({
+        "//conditions:default": [
+        ],
+    }),
+)
+
+alias(
+    # Because `cargo_build_script` does some invisible target name mutating to
+    # determine the package and crate name for a build script, the Bazel
+    # target namename of any build script cannot be the Cargo canonical name
+    # of `build_script_build` without losing out on having certain Cargo
+    # environment variables set.
+    name = "build_script_build",
+    actual = "winapi-x86_64-pc-windows-gnu_build_script",
+    tags = [
+        "manual",
+    ],
+)
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/crates.bzl b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/crates.bzl
new file mode 100644
index 0000000..c30f4a0
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/crates.bzl
@@ -0,0 +1,25 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""Rules for defining repositories for remote `crates_vendor` repositories"""
+
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+# buildifier: disable=bzl-visibility
+load("@examples//vendor_remote_pkgs/crates:defs.bzl", _crate_repositories = "crate_repositories")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//crate_universe/private:crates_vendor.bzl", "crates_vendor_remote_repository")
+
+def crate_repositories():
+    maybe(
+        crates_vendor_remote_repository,
+        name = "crates_vendor_pkgs",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.bazel"),
+        defs_module = Label("@examples//vendor_remote_pkgs/crates:defs.bzl"),
+    )
+
+    _crate_repositories()
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/defs.bzl b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/defs.bzl
new file mode 100644
index 0000000..ad7dac5
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/crates/defs.bzl
@@ -0,0 +1,1204 @@
+###############################################################################
+# @generated
+# This file is auto-generated by the cargo-bazel tool.
+#
+# DO NOT MODIFY: Local changes may be replaced in future executions.
+###############################################################################
+"""
+# `crates_repository` API
+
+- [aliases](#aliases)
+- [crate_deps](#crate_deps)
+- [all_crate_deps](#all_crate_deps)
+- [crate_repositories](#crate_repositories)
+
+"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+###############################################################################
+# MACROS API
+###############################################################################
+
+# An identifier that represent common dependencies (unconditional).
+_COMMON_CONDITION = ""
+
+def _flatten_dependency_maps(all_dependency_maps):
+    """Flatten a list of dependency maps into one dictionary.
+
+    Dependency maps have the following structure:
+
+    ```python
+    DEPENDENCIES_MAP = {
+        # The first key in the map is a Bazel package
+        # name of the workspace this file is defined in.
+        "workspace_member_package": {
+
+            # Not all dependnecies are supported for all platforms.
+            # the condition key is the condition required to be true
+            # on the host platform.
+            "condition": {
+
+                # An alias to a crate target.     # The label of the crate target the
+                # Aliases are only crate names.   # package name refers to.
+                "package_name":                   "@full//:label",
+            }
+        }
+    }
+    ```
+
+    Args:
+        all_dependency_maps (list): A list of dicts as described above
+
+    Returns:
+        dict: A dictionary as described above
+    """
+    dependencies = {}
+
+    for workspace_deps_map in all_dependency_maps:
+        for pkg_name, conditional_deps_map in workspace_deps_map.items():
+            if pkg_name not in dependencies:
+                non_frozen_map = dict()
+                for key, values in conditional_deps_map.items():
+                    non_frozen_map.update({key: dict(values.items())})
+                dependencies.setdefault(pkg_name, non_frozen_map)
+                continue
+
+            for condition, deps_map in conditional_deps_map.items():
+                # If the condition has not been recorded, do so and continue
+                if condition not in dependencies[pkg_name]:
+                    dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))
+                    continue
+
+                # Alert on any miss-matched dependencies
+                inconsistent_entries = []
+                for crate_name, crate_label in deps_map.items():
+                    existing = dependencies[pkg_name][condition].get(crate_name)
+                    if existing and existing != crate_label:
+                        inconsistent_entries.append((crate_name, existing, crate_label))
+                    dependencies[pkg_name][condition].update({crate_name: crate_label})
+
+    return dependencies
+
+def crate_deps(deps, package_name = None):
+    """Finds the fully qualified label of the requested crates for the package where this macro is called.
+
+    Args:
+        deps (list): The desired list of crate targets.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()`.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if not deps:
+        return []
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Join both sets of dependencies
+    dependencies = _flatten_dependency_maps([
+        _NORMAL_DEPENDENCIES,
+        _NORMAL_DEV_DEPENDENCIES,
+        _PROC_MACRO_DEPENDENCIES,
+        _PROC_MACRO_DEV_DEPENDENCIES,
+        _BUILD_DEPENDENCIES,
+        _BUILD_PROC_MACRO_DEPENDENCIES,
+    ]).pop(package_name, {})
+
+    # Combine all conditional packages so we can easily index over a flat list
+    # TODO: Perhaps this should actually return select statements and maintain
+    # the conditionals of the dependencies
+    flat_deps = {}
+    for deps_set in dependencies.values():
+        for crate_name, crate_label in deps_set.items():
+            flat_deps.update({crate_name: crate_label})
+
+    missing_crates = []
+    crate_targets = []
+    for crate_target in deps:
+        if crate_target not in flat_deps:
+            missing_crates.append(crate_target)
+        else:
+            crate_targets.append(flat_deps[crate_target])
+
+    if missing_crates:
+        fail("Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`".format(
+            missing_crates,
+            package_name,
+            dependencies,
+        ))
+
+    return crate_targets
+
+def all_crate_deps(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Finds the fully qualified label of all requested direct crate dependencies \
+    for the package where this macro is called.
+
+    If no parameters are set, all normal dependencies are returned. Setting any one flag will
+    otherwise impact the contents of the returned list.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        list: A list of labels to generated rust targets (str)
+    """
+
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_dependency_maps = []
+    if normal:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+    if normal_dev:
+        all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)
+    if proc_macro:
+        all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)
+    if proc_macro_dev:
+        all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)
+    if build:
+        all_dependency_maps.append(_BUILD_DEPENDENCIES)
+    if build_proc_macro:
+        all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)
+
+    # Default to always using normal dependencies
+    if not all_dependency_maps:
+        all_dependency_maps.append(_NORMAL_DEPENDENCIES)
+
+    dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)
+
+    if not dependencies:
+        return []
+
+    crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())
+    for condition, deps in dependencies.items():
+        crate_deps += selects.with_or({_CONDITIONS[condition]: deps.values()})
+
+    return crate_deps
+
+def aliases(
+        normal = False,
+        normal_dev = False,
+        proc_macro = False,
+        proc_macro_dev = False,
+        build = False,
+        build_proc_macro = False,
+        package_name = None):
+    """Produces a map of Crate alias names to their original label
+
+    If no dependency kinds are specified, `normal` and `proc_macro` are used by default.
+    Setting any one flag will otherwise determine the contents of the returned dict.
+
+    Args:
+        normal (bool, optional): If True, normal dependencies are included in the
+            output list.
+        normal_dev (bool, optional): If True, normla dev dependencies will be
+            included in the output list..
+        proc_macro (bool, optional): If True, proc_macro dependencies are included
+            in the output list.
+        proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are
+            included in the output list.
+        build (bool, optional): If True, build dependencies are included
+            in the output list.
+        build_proc_macro (bool, optional): If True, build proc_macro dependencies are
+            included in the output list.
+        package_name (str, optional): The package name of the set of dependencies to look up.
+            Defaults to `native.package_name()` when unset.
+
+    Returns:
+        dict: The aliases of all associated packages
+    """
+    if package_name == None:
+        package_name = native.package_name()
+
+    # Determine the relevant maps to use
+    all_aliases_maps = []
+    if normal:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+    if normal_dev:
+        all_aliases_maps.append(_NORMAL_DEV_ALIASES)
+    if proc_macro:
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+    if proc_macro_dev:
+        all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)
+    if build:
+        all_aliases_maps.append(_BUILD_ALIASES)
+    if build_proc_macro:
+        all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)
+
+    # Default to always using normal aliases
+    if not all_aliases_maps:
+        all_aliases_maps.append(_NORMAL_ALIASES)
+        all_aliases_maps.append(_PROC_MACRO_ALIASES)
+
+    aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)
+
+    if not aliases:
+        return dict()
+
+    common_items = aliases.pop(_COMMON_CONDITION, {}).items()
+
+    # If there are only common items in the dictionary, immediately return them
+    if not len(aliases.keys()) == 1:
+        return dict(common_items)
+
+    # Build a single select statement where each conditional has accounted for the
+    # common set of aliases.
+    crate_aliases = {"//conditions:default": common_items}
+    for condition, deps in aliases.items():
+        condition_triples = _CONDITIONS[condition]
+        if condition_triples in crate_aliases:
+            crate_aliases[condition_triples].update(deps)
+        else:
+            crate_aliases.update({_CONDITIONS[condition]: dict(deps.items() + common_items)})
+
+    return selects.with_or(crate_aliases)
+
+###############################################################################
+# WORKSPACE MEMBER DEPS AND ALIASES
+###############################################################################
+
+_NORMAL_DEPENDENCIES = {
+    "": {
+        _COMMON_CONDITION: {
+            "axum": "@crates_vendor_pkgs__axum-0.4.8//:axum",
+            "hyper": "@crates_vendor_pkgs__hyper-0.14.17//:hyper",
+            "mime": "@crates_vendor_pkgs__mime-0.3.16//:mime",
+            "serde_json": "@crates_vendor_pkgs__serde_json-1.0.79//:serde_json",
+            "tokio": "@crates_vendor_pkgs__tokio-1.16.1//:tokio",
+            "tower": "@crates_vendor_pkgs__tower-0.4.12//:tower",
+            "tower-http": "@crates_vendor_pkgs__tower-http-0.2.3//:tower_http",
+            "tracing": "@crates_vendor_pkgs__tracing-0.1.31//:tracing",
+            "tracing-subscriber": "@crates_vendor_pkgs__tracing-subscriber-0.3.9//:tracing_subscriber",
+        },
+    },
+}
+
+_NORMAL_ALIASES = {
+    "": {
+        _COMMON_CONDITION: {
+        },
+    },
+}
+
+_NORMAL_DEV_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_NORMAL_DEV_ALIASES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_ALIASES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEV_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_PROC_MACRO_DEV_ALIASES = {
+    "": {
+    },
+}
+
+_BUILD_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_BUILD_ALIASES = {
+    "": {
+    },
+}
+
+_BUILD_PROC_MACRO_DEPENDENCIES = {
+    "": {
+    },
+}
+
+_BUILD_PROC_MACRO_ALIASES = {
+    "": {
+    },
+}
+
+_CONDITIONS = {
+    "cfg(all(any(target_arch = \"x86_64\", target_arch = \"aarch64\"), target_os = \"hermit\"))": [],
+    "cfg(not(windows))": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasi", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(target_os = \"redox\")": [],
+    "cfg(target_os = \"windows\")": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "cfg(tracing_unstable)": [],
+    "cfg(unix)": ["aarch64-apple-darwin", "aarch64-apple-ios", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "arm-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi", "i686-apple-darwin", "i686-linux-android", "i686-unknown-freebsd", "i686-unknown-linux-gnu", "powerpc-unknown-linux-gnu", "s390x-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-apple-ios", "x86_64-linux-android", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"],
+    "cfg(windows)": ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc"],
+    "i686-pc-windows-gnu": [],
+    "x86_64-pc-windows-gnu": [],
+}
+
+###############################################################################
+
+def crate_repositories():
+    """A macro for defining repositories for all generated crates"""
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__ansi_term-0.12.1",
+        sha256 = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ansi_term/0.12.1/download"],
+        strip_prefix = "ansi_term-0.12.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.ansi_term-0.12.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__async-trait-0.1.52",
+        sha256 = "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/async-trait/0.1.52/download"],
+        strip_prefix = "async-trait-0.1.52",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.async-trait-0.1.52.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__autocfg-1.1.0",
+        sha256 = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/autocfg/1.1.0/download"],
+        strip_prefix = "autocfg-1.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.autocfg-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__axum-0.4.8",
+        sha256 = "c9f346c92c1e9a71d14fe4aaf7c2a5d9932cc4e5e48d8fb6641524416eb79ddd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/axum/0.4.8/download"],
+        strip_prefix = "axum-0.4.8",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.axum-0.4.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__axum-core-0.1.2",
+        sha256 = "6dbcda393bef9c87572779cb8ef916f12d77750b27535dd6819fa86591627a51",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/axum-core/0.1.2/download"],
+        strip_prefix = "axum-core-0.1.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.axum-core-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__bitflags-1.3.2",
+        sha256 = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bitflags/1.3.2/download"],
+        strip_prefix = "bitflags-1.3.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.bitflags-1.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__bytes-1.1.0",
+        sha256 = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/bytes/1.1.0/download"],
+        strip_prefix = "bytes-1.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.bytes-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__cfg-if-1.0.0",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/cfg-if/1.0.0/download"],
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__fnv-1.0.7",
+        sha256 = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/fnv/1.0.7/download"],
+        strip_prefix = "fnv-1.0.7",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.fnv-1.0.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__form_urlencoded-1.0.1",
+        sha256 = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download"],
+        strip_prefix = "form_urlencoded-1.0.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.form_urlencoded-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__futures-channel-0.3.21",
+        sha256 = "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-channel/0.3.21/download"],
+        strip_prefix = "futures-channel-0.3.21",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.futures-channel-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__futures-core-0.3.21",
+        sha256 = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-core/0.3.21/download"],
+        strip_prefix = "futures-core-0.3.21",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.futures-core-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__futures-sink-0.3.21",
+        sha256 = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-sink/0.3.21/download"],
+        strip_prefix = "futures-sink-0.3.21",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.futures-sink-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__futures-task-0.3.21",
+        sha256 = "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-task/0.3.21/download"],
+        strip_prefix = "futures-task-0.3.21",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.futures-task-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__futures-util-0.3.21",
+        sha256 = "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/futures-util/0.3.21/download"],
+        strip_prefix = "futures-util-0.3.21",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.futures-util-0.3.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__h2-0.3.11",
+        sha256 = "d9f1f717ddc7b2ba36df7e871fd88db79326551d3d6f1fc406fbfd28b582ff8e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/h2/0.3.11/download"],
+        strip_prefix = "h2-0.3.11",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.h2-0.3.11.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__hashbrown-0.11.2",
+        sha256 = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hashbrown/0.11.2/download"],
+        strip_prefix = "hashbrown-0.11.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.hashbrown-0.11.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__hermit-abi-0.1.19",
+        sha256 = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hermit-abi/0.1.19/download"],
+        strip_prefix = "hermit-abi-0.1.19",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.hermit-abi-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__http-0.2.6",
+        sha256 = "31f4c6746584866f0feabcc69893c5b51beef3831656a968ed7ae254cdc4fd03",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/http/0.2.6/download"],
+        strip_prefix = "http-0.2.6",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.http-0.2.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__http-body-0.4.4",
+        sha256 = "1ff4f84919677303da5f147645dbea6b1881f368d03ac84e1dc09031ebd7b2c6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/http-body/0.4.4/download"],
+        strip_prefix = "http-body-0.4.4",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.http-body-0.4.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__http-range-header-0.3.0",
+        sha256 = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/http-range-header/0.3.0/download"],
+        strip_prefix = "http-range-header-0.3.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.http-range-header-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__httparse-1.6.0",
+        sha256 = "9100414882e15fb7feccb4897e5f0ff0ff1ca7d1a86a23208ada4d7a18e6c6c4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/httparse/1.6.0/download"],
+        strip_prefix = "httparse-1.6.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.httparse-1.6.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__httpdate-1.0.2",
+        sha256 = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/httpdate/1.0.2/download"],
+        strip_prefix = "httpdate-1.0.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.httpdate-1.0.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__hyper-0.14.17",
+        sha256 = "043f0e083e9901b6cc658a77d1eb86f4fc650bbb977a4337dd63192826aa85dd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/hyper/0.14.17/download"],
+        strip_prefix = "hyper-0.14.17",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.hyper-0.14.17.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__indexmap-1.8.0",
+        sha256 = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/indexmap/1.8.0/download"],
+        strip_prefix = "indexmap-1.8.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.indexmap-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__instant-0.1.12",
+        sha256 = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/instant/0.1.12/download"],
+        strip_prefix = "instant-0.1.12",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.instant-0.1.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__itoa-1.0.1",
+        sha256 = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/itoa/1.0.1/download"],
+        strip_prefix = "itoa-1.0.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.itoa-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__lazy_static-1.4.0",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/lazy_static/1.4.0/download"],
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__libc-0.2.119",
+        sha256 = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/libc/0.2.119/download"],
+        strip_prefix = "libc-0.2.119",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.libc-0.2.119.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__lock_api-0.4.6",
+        sha256 = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/lock_api/0.4.6/download"],
+        strip_prefix = "lock_api-0.4.6",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.lock_api-0.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__log-0.4.14",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/log/0.4.14/download"],
+        strip_prefix = "log-0.4.14",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__matches-0.1.9",
+        sha256 = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/matches/0.1.9/download"],
+        strip_prefix = "matches-0.1.9",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.matches-0.1.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__matchit-0.4.6",
+        sha256 = "9376a4f0340565ad675d11fc1419227faf5f60cd7ac9cb2e7185a471f30af833",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/matchit/0.4.6/download"],
+        strip_prefix = "matchit-0.4.6",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.matchit-0.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__memchr-2.4.1",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/memchr/2.4.1/download"],
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__mime-0.3.16",
+        sha256 = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/mime/0.3.16/download"],
+        strip_prefix = "mime-0.3.16",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.mime-0.3.16.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__mio-0.7.14",
+        sha256 = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/mio/0.7.14/download"],
+        strip_prefix = "mio-0.7.14",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.mio-0.7.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__miow-0.3.7",
+        sha256 = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/miow/0.3.7/download"],
+        strip_prefix = "miow-0.3.7",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.miow-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__ntapi-0.3.7",
+        sha256 = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ntapi/0.3.7/download"],
+        strip_prefix = "ntapi-0.3.7",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.ntapi-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__num_cpus-1.13.1",
+        sha256 = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/num_cpus/1.13.1/download"],
+        strip_prefix = "num_cpus-1.13.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.num_cpus-1.13.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__once_cell-1.9.0",
+        sha256 = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/once_cell/1.9.0/download"],
+        strip_prefix = "once_cell-1.9.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.once_cell-1.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__parking_lot-0.11.2",
+        sha256 = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/parking_lot/0.11.2/download"],
+        strip_prefix = "parking_lot-0.11.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.parking_lot-0.11.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__parking_lot_core-0.8.5",
+        sha256 = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/parking_lot_core/0.8.5/download"],
+        strip_prefix = "parking_lot_core-0.8.5",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.parking_lot_core-0.8.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__percent-encoding-2.1.0",
+        sha256 = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/percent-encoding/2.1.0/download"],
+        strip_prefix = "percent-encoding-2.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.percent-encoding-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__pin-project-1.0.10",
+        sha256 = "58ad3879ad3baf4e44784bc6a718a8698867bb991f8ce24d1bcbe2cfb4c3a75e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pin-project/1.0.10/download"],
+        strip_prefix = "pin-project-1.0.10",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.pin-project-1.0.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__pin-project-internal-1.0.10",
+        sha256 = "744b6f092ba29c3650faf274db506afd39944f48420f6c86b17cfe0ee1cb36bb",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pin-project-internal/1.0.10/download"],
+        strip_prefix = "pin-project-internal-1.0.10",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.pin-project-internal-1.0.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__pin-project-lite-0.2.8",
+        sha256 = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pin-project-lite/0.2.8/download"],
+        strip_prefix = "pin-project-lite-0.2.8",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.pin-project-lite-0.2.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__pin-utils-0.1.0",
+        sha256 = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/pin-utils/0.1.0/download"],
+        strip_prefix = "pin-utils-0.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.pin-utils-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__proc-macro2-1.0.36",
+        sha256 = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/proc-macro2/1.0.36/download"],
+        strip_prefix = "proc-macro2-1.0.36",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.proc-macro2-1.0.36.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__quote-1.0.15",
+        sha256 = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/quote/1.0.15/download"],
+        strip_prefix = "quote-1.0.15",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.quote-1.0.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__redox_syscall-0.2.11",
+        sha256 = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/redox_syscall/0.2.11/download"],
+        strip_prefix = "redox_syscall-0.2.11",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.redox_syscall-0.2.11.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__ryu-1.0.9",
+        sha256 = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/ryu/1.0.9/download"],
+        strip_prefix = "ryu-1.0.9",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.ryu-1.0.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__scopeguard-1.1.0",
+        sha256 = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/scopeguard/1.1.0/download"],
+        strip_prefix = "scopeguard-1.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.scopeguard-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__serde-1.0.136",
+        sha256 = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde/1.0.136/download"],
+        strip_prefix = "serde-1.0.136",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.serde-1.0.136.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__serde_json-1.0.79",
+        sha256 = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde_json/1.0.79/download"],
+        strip_prefix = "serde_json-1.0.79",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.serde_json-1.0.79.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__serde_urlencoded-0.7.1",
+        sha256 = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/serde_urlencoded/0.7.1/download"],
+        strip_prefix = "serde_urlencoded-0.7.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.serde_urlencoded-0.7.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__sharded-slab-0.1.4",
+        sha256 = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/sharded-slab/0.1.4/download"],
+        strip_prefix = "sharded-slab-0.1.4",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.sharded-slab-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__signal-hook-registry-1.4.0",
+        sha256 = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/signal-hook-registry/1.4.0/download"],
+        strip_prefix = "signal-hook-registry-1.4.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.signal-hook-registry-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__slab-0.4.5",
+        sha256 = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/slab/0.4.5/download"],
+        strip_prefix = "slab-0.4.5",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.slab-0.4.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__smallvec-1.8.0",
+        sha256 = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/smallvec/1.8.0/download"],
+        strip_prefix = "smallvec-1.8.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.smallvec-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__socket2-0.4.4",
+        sha256 = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/socket2/0.4.4/download"],
+        strip_prefix = "socket2-0.4.4",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.socket2-0.4.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__syn-1.0.86",
+        sha256 = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/syn/1.0.86/download"],
+        strip_prefix = "syn-1.0.86",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.syn-1.0.86.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__sync_wrapper-0.1.1",
+        sha256 = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/sync_wrapper/0.1.1/download"],
+        strip_prefix = "sync_wrapper-0.1.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.sync_wrapper-0.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__thread_local-1.1.4",
+        sha256 = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/thread_local/1.1.4/download"],
+        strip_prefix = "thread_local-1.1.4",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.thread_local-1.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tokio-1.16.1",
+        sha256 = "0c27a64b625de6d309e8c57716ba93021dccf1b3b5c97edd6d3dd2d2135afc0a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio/1.16.1/download"],
+        strip_prefix = "tokio-1.16.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tokio-1.16.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tokio-macros-1.7.0",
+        sha256 = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-macros/1.7.0/download"],
+        strip_prefix = "tokio-macros-1.7.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tokio-macros-1.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tokio-util-0.6.9",
+        sha256 = "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-util/0.6.9/download"],
+        strip_prefix = "tokio-util-0.6.9",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tokio-util-0.6.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tokio-util-0.7.0",
+        sha256 = "64910e1b9c1901aaf5375561e35b9c057d95ff41a44ede043a03e09279eabaf1",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tokio-util/0.7.0/download"],
+        strip_prefix = "tokio-util-0.7.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tokio-util-0.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tower-0.4.12",
+        sha256 = "9a89fd63ad6adf737582df5db40d286574513c69a11dac5214dc3b5603d6713e",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tower/0.4.12/download"],
+        strip_prefix = "tower-0.4.12",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tower-0.4.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tower-http-0.2.3",
+        sha256 = "2bb284cac1883d54083a0edbdc9cabf931dfed87455f8c7266c01ece6394a43a",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tower-http/0.2.3/download"],
+        strip_prefix = "tower-http-0.2.3",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tower-http-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tower-layer-0.3.1",
+        sha256 = "343bc9466d3fe6b0f960ef45960509f84480bf4fd96f92901afe7ff3df9d3a62",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tower-layer/0.3.1/download"],
+        strip_prefix = "tower-layer-0.3.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tower-layer-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tower-service-0.3.1",
+        sha256 = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tower-service/0.3.1/download"],
+        strip_prefix = "tower-service-0.3.1",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tower-service-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tracing-0.1.31",
+        sha256 = "f6c650a8ef0cd2dd93736f033d21cbd1224c5a967aa0c258d00fcf7dafef9b9f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tracing/0.1.31/download"],
+        strip_prefix = "tracing-0.1.31",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tracing-0.1.31.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tracing-attributes-0.1.19",
+        sha256 = "8276d9a4a3a558d7b7ad5303ad50b53d58264641b82914b7ada36bd762e7a716",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tracing-attributes/0.1.19/download"],
+        strip_prefix = "tracing-attributes-0.1.19",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tracing-attributes-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tracing-core-0.1.22",
+        sha256 = "03cfcb51380632a72d3111cb8d3447a8d908e577d31beeac006f836383d29a23",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tracing-core/0.1.22/download"],
+        strip_prefix = "tracing-core-0.1.22",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tracing-core-0.1.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tracing-log-0.1.2",
+        sha256 = "a6923477a48e41c1951f1999ef8bb5a3023eb723ceadafe78ffb65dc366761e3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tracing-log/0.1.2/download"],
+        strip_prefix = "tracing-log-0.1.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tracing-log-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__tracing-subscriber-0.3.9",
+        sha256 = "9e0ab7bdc962035a87fba73f3acca9b8a8d0034c2e6f60b84aeaaddddc155dce",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/tracing-subscriber/0.3.9/download"],
+        strip_prefix = "tracing-subscriber-0.3.9",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.tracing-subscriber-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__try-lock-0.2.3",
+        sha256 = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/try-lock/0.2.3/download"],
+        strip_prefix = "try-lock-0.2.3",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.try-lock-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__unicode-xid-0.2.2",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/unicode-xid/0.2.2/download"],
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__valuable-0.1.0",
+        sha256 = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/valuable/0.1.0/download"],
+        strip_prefix = "valuable-0.1.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.valuable-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__want-0.3.0",
+        sha256 = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/want/0.3.0/download"],
+        strip_prefix = "want-0.3.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.want-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__winapi-0.3.9",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi/0.3.9/download"],
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__winapi-i686-pc-windows-gnu-0.4.0",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "crates_vendor_pkgs__winapi-x86_64-pc-windows-gnu-0.4.0",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        type = "tar.gz",
+        urls = ["https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download"],
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("@examples//vendor_remote_pkgs/crates:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
diff --git a/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/src/main.rs b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/src/main.rs
new file mode 100644
index 0000000..edde4b6
--- /dev/null
+++ b/third_party/rules_rust/examples/crate_universe/vendor_remote_pkgs/src/main.rs
@@ -0,0 +1,150 @@
+//! Copied from https://github.com/tokio-rs/axum/blob/v0.2.5/examples/testing/src/main.rs
+
+use axum::{
+    routing::{get, post},
+    Json, Router,
+};
+use tower_http::trace::TraceLayer;
+
+#[tokio::main]
+async fn main() {
+    // Set the RUST_LOG, if it hasn't been explicitly defined
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "example_testing=debug,tower_http=debug")
+    }
+    tracing_subscriber::fmt::init();
+
+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 3000));
+
+    tracing::debug!("listening on {}", addr);
+
+    axum::Server::bind(&addr)
+        .serve(app().into_make_service())
+        .await
+        .unwrap();
+}
+
+/// Having a function that produces our app makes it easy to call it from tests
+/// without having to create an HTTP server.
+#[allow(dead_code)]
+fn app() -> Router {
+    Router::new()
+        .route("/", get(|| async { "Hello, World!" }))
+        .route(
+            "/json",
+            post(|payload: Json<serde_json::Value>| async move {
+                Json(serde_json::json!({ "data": payload.0 }))
+            }),
+        )
+        // We can still add middleware
+        .layer(TraceLayer::new_for_http())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(not(target_os = "windows"))]
+    use std::net::{SocketAddr, TcpListener};
+
+    use axum::{
+        body::Body,
+        http::{self, Request, StatusCode},
+    };
+    use serde_json::{json, Value};
+    use tower::ServiceExt; // for `app.oneshot()`
+
+    #[tokio::test]
+    async fn hello_world() {
+        let app = app();
+
+        // `Router` implements `tower::Service<Request<Body>>` so we can
+        // call it like any tower service, no need to run an HTTP server.
+        let response = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn json() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(http::Method::POST)
+                    .uri("/json")
+                    .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
+                    .body(Body::from(
+                        serde_json::to_vec(&json!([1_i8, 2_i8, 3_i8, 4_i8])).unwrap(),
+                    ))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        let body: Value = serde_json::from_slice(&body).unwrap();
+        assert_eq!(body, json!({ "data": [1_i8, 2_i8, 3_i8, 4_i8] }));
+    }
+
+    #[tokio::test]
+    async fn not_found() {
+        let app = app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/does-not-exist")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert!(body.is_empty());
+    }
+
+    // TODO: This test fails on Windows, it shouldn't but it's unclear to me
+    // if this is an issue on the host or with the test.
+    #[cfg(not(target_os = "windows"))]
+    // You can also spawn a server and talk to it like any other HTTP server:
+    #[tokio::test]
+    async fn the_real_deal() {
+        let listener = TcpListener::bind("0.0.0.0:0".parse::<SocketAddr>().unwrap()).unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        tokio::spawn(async move {
+            axum::Server::from_tcp(listener)
+                .unwrap()
+                .serve(app().into_make_service())
+                .await
+                .unwrap();
+        });
+
+        let client = hyper::Client::new();
+
+        let response = client
+            .request(
+                Request::builder()
+                    .uri(format!("http://{}", addr))
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+}
diff --git a/third_party/rules_rust/examples/env_locations/BUILD.bazel b/third_party/rules_rust/examples/env_locations/BUILD.bazel
new file mode 100644
index 0000000..82161bb
--- /dev/null
+++ b/third_party/rules_rust/examples/env_locations/BUILD.bazel
@@ -0,0 +1,49 @@
+load("@rules_rust//cargo:cargo_build_script.bzl", "cargo_build_script")
+load("@rules_rust//rust:defs.bzl", "rust_test")
+
+# generate a file
+genrule(
+    name = "data_generator",
+    outs = ["generated.data"],
+    cmd = "echo hello > $@",
+)
+
+_data = [
+    # we should be able to read non-generated source/data files
+    "source.file",
+    # and generated files as well
+    "generated.data",
+    # we should also be able to access external binaries
+    # such as protoc.
+    "@com_google_protobuf//:protoc",
+]
+
+cargo_build_script(
+    name = "build",
+    srcs = ["build.rs"],
+    build_script_env = {
+        "GENERATED_DATA": "$(location generated.data)",
+        "SOME_TOOL": "$(execpath @com_google_protobuf//:protoc)",
+        # both execpath and location should work
+        "SOURCE_FILE": "$(execpath source.file)",
+    },
+    data = _data,
+)
+
+rust_test(
+    name = "test",
+    srcs = [
+        "main.rs",
+    ],
+    data = _data,
+    edition = "2018",
+    rustc_env = {
+        "GENERATED_DATA_ABS": "$(execpath generated.data)",
+        "GENERATED_DATA_ROOT": "$(rootpath generated.data)",
+        "SOME_TOOL": "$(rootpath @com_google_protobuf//:protoc)",
+        "SOURCE_FILE": "$(rootpath source.file)",
+    },
+    deps = [
+        ":build",
+    ],
+)
diff --git a/third_party/rules_rust/examples/env_locations/build.rs b/third_party/rules_rust/examples/env_locations/build.rs
new file mode 100644
index 0000000..d791f5d
--- /dev/null
+++ b/third_party/rules_rust/examples/env_locations/build.rs
@@ -0,0 +1,17 @@
+use std::{env, fs};
+
+fn main() {
+    // our source file should be readable
+    let path = env::var("SOURCE_FILE").unwrap();
+    let generated_data = fs::read_to_string(&path).unwrap();
+    assert_eq!(generated_data, "source\n");
+
+    // our generated data file should be readable
+    let path = env::var("GENERATED_DATA").unwrap();
+    let generated_data = fs::read_to_string(&path).unwrap();
+    assert_eq!(generated_data, "hello\n");
+
+    // and we should be able to read (and thus execute) our tool
+    let path = env::var("SOME_TOOL").unwrap();
+    assert!(!fs::read(&path).unwrap().is_empty());
+}
diff --git a/third_party/rules_rust/examples/env_locations/main.rs b/third_party/rules_rust/examples/env_locations/main.rs
new file mode 100644
index 0000000..3b07b1d
--- /dev/null
+++ b/third_party/rules_rust/examples/env_locations/main.rs
@@ -0,0 +1,12 @@
+#[test]
+fn test() {
+    // our source file should be readable
+    let source_file = std::fs::read_to_string(env!("SOURCE_FILE")).unwrap();
+    assert_eq!(source_file, "source\n");
+    // our generated data file should be readable at run time and build time
+    let generated_data = std::fs::read_to_string(env!("GENERATED_DATA_ROOT")).unwrap();
+    let generated_data2 = include_str!(env!("GENERATED_DATA_ABS"));
+    assert_eq!(generated_data, generated_data2);
+    // and we should be able to read (and thus execute) our tool
+    assert!(!std::fs::read(env!("SOME_TOOL")).unwrap().is_empty());
+}
diff --git a/third_party/rules_rust/examples/env_locations/source.file b/third_party/rules_rust/examples/env_locations/source.file
new file mode 100644
index 0000000..5a18cd2
--- /dev/null
+++ b/third_party/rules_rust/examples/env_locations/source.file
@@ -0,0 +1 @@
+source
diff --git a/third_party/rules_rust/examples/ffi/BUILD.bazel b/third_party/rules_rust/examples/ffi/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/BUILD.bazel
diff --git a/third_party/rules_rust/examples/ffi/c_calling_rust/BUILD.bazel b/third_party/rules_rust/examples/ffi/c_calling_rust/BUILD.bazel
new file mode 100644
index 0000000..b491126
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/c_calling_rust/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@rules_cc//cc:defs.bzl", "cc_test")
+load("@rules_rust//rust:defs.bzl", "rust_static_library", "rust_test")
+
+rust_static_library(
+    name = "rusty",
+    srcs = ["lib.rs"],
+)
+
+rust_test(
+    name = "rusty_test",
+    crate = ":rusty",
+)
+
+cc_test(
+    name = "main",
+    srcs = ["main.c"],
+    deps = [":rusty"],
+)
diff --git a/third_party/rules_rust/examples/ffi/c_calling_rust/lib.rs b/third_party/rules_rust/examples/ffi/c_calling_rust/lib.rs
new file mode 100644
index 0000000..2d6fc52
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/c_calling_rust/lib.rs
@@ -0,0 +1,14 @@
+#[no_mangle]
+pub extern "C" fn my_favorite_number() -> i32 {
+    4
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_my_favorite_number() {
+        assert_eq!(4, my_favorite_number());
+    }
+}
diff --git a/third_party/rules_rust/examples/ffi/c_calling_rust/main.c b/third_party/rules_rust/examples/ffi/c_calling_rust/main.c
new file mode 100644
index 0000000..2a57330
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/c_calling_rust/main.c
@@ -0,0 +1,9 @@
+#include <assert.h>
+#include <stdint.h>
+
+extern int32_t my_favorite_number();
+
+int main(int argc, char** argv) {
+  assert(my_favorite_number() == 4);
+  return 0;
+}
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/BUILD.bazel b/third_party/rules_rust/examples/ffi/rust_calling_c/BUILD.bazel
new file mode 100644
index 0000000..041d1da
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/BUILD.bazel
@@ -0,0 +1,62 @@
+load("@rules_rust//rust:defs.bzl", "rust_doc", "rust_library", "rust_test")
+
+package(default_visibility = ["//ffi/rust_calling_c:__subpackages__"])
+
+rust_library(
+    name = "matrix",
+    srcs = [
+        "src/ffi.rs",
+        "src/matrix.rs",
+    ],
+    deps = [
+        "//ffi/rust_calling_c/c:native_matrix",
+        "@libc",
+    ],
+)
+
+rust_test(
+    name = "matrix_test",
+    crate = ":matrix",
+)
+
+rust_doc(
+    name = "matrix_doc",
+    crate = ":matrix",
+)
+
+## Do the same as above, but with a dynamic c library.
+
+rust_library(
+    name = "matrix_dynamically_linked",
+    srcs = [
+        "src/ffi.rs",
+        "src/matrix.rs",
+    ],
+    crate_root = "src/matrix.rs",
+    target_compatible_with = select({
+        # TODO: Make this work on windows
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
+    deps = [
+        "//ffi/rust_calling_c/c:native_matrix_so",
+        "@libc",
+    ],
+)
+
+rust_test(
+    name = "matrix_dylib_test",
+    crate = ":matrix_dynamically_linked",
+    target_compatible_with = select({
+        # TODO: This test requires --incompatible_macos_set_install_name and Bazel 4.2.0+
+        "@platforms//os:macos": ["@platforms//:incompatible"],
+        # TODO: Make this work on windows
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
+)
+
+rust_doc(
+    name = "matrix_dylib_doc",
+    crate = ":matrix_dynamically_linked",
+)
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/c/BUILD.bazel b/third_party/rules_rust/examples/ffi/rust_calling_c/c/BUILD.bazel
new file mode 100644
index 0000000..2cab18b
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/c/BUILD.bazel
@@ -0,0 +1,38 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_import", "cc_library", "cc_test")
+
+package(default_visibility = ["//ffi/rust_calling_c:__subpackages__"])
+
+cc_library(
+    name = "native_matrix",
+    srcs = ["matrix.c"],
+    hdrs = ["matrix.h"],
+    copts = ["-std=c99"],
+)
+
+cc_test(
+    name = "native_matrix_test",
+    srcs = ["matrix_test.c"],
+    copts = ["-std=c99"],
+    linkstatic = 1,
+    deps = [
+        ":native_matrix",
+    ],
+)
+
+## Do the same as above, but with a dynamic c library.
+
+cc_import(
+    name = "native_matrix_so",
+    hdrs = ["matrix.h"],
+    shared_library = ":libnative_matrix_so.so",
+)
+
+cc_binary(
+    name = "libnative_matrix_so.so",
+    srcs = [
+        "matrix.c",
+        "matrix.h",
+    ],
+    copts = ["-std=c99"],
+    linkshared = True,
+)
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.c b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.c
new file mode 100644
index 0000000..6a4c811
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.c
@@ -0,0 +1,123 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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 "ffi/rust_calling_c/c/matrix.h"
+
+#include <stdio.h>
+#include <string.h>
+
+Matrix* matrix_new(size_t rows, size_t cols, const uint64_t* data) {
+  if (data == NULL) {
+    return NULL;
+  }
+  Matrix* matrix = (Matrix*)malloc(sizeof(*matrix));
+  if (matrix == NULL) {
+    return NULL;
+  }
+  matrix->rows = rows;
+  matrix->cols = cols;
+  matrix->data = (uint64_t*)malloc(rows * cols * sizeof(*(matrix->data)));
+  memcpy(matrix->data, data, rows * cols * sizeof(*data));
+  return matrix;
+}
+
+int matrix_at(const Matrix* matrix, size_t row, size_t col, uint64_t* n) {
+  if (matrix == NULL || matrix->data == NULL || n == NULL) {
+    return 0;
+  }
+  if (row >= matrix->rows || col >= matrix->cols) {
+    return 0;
+  }
+  *n = matrix->data[row * matrix->cols + col];
+  return 1;
+}
+
+int matrix_set(const Matrix* matrix, size_t row, size_t col, uint64_t n) {
+  if (matrix == NULL || matrix->data == NULL) {
+    return 0;
+  }
+  if (row >= matrix->rows || col >= matrix->cols) {
+    return 0;
+  }
+  matrix->data[row * matrix->cols + col] = n;
+  return 1;
+}
+
+void matrix_transpose(Matrix* matrix) {
+  if (matrix == NULL || matrix->data == NULL) {
+    return;
+  }
+
+  size_t len = matrix->rows * matrix->cols;
+  int* visited = (int*)malloc(len * sizeof(*visited));
+  if (visited == NULL) {
+    return;
+  }
+  memset(visited, 0, len * sizeof(*visited));
+
+  // Follow-the-cycles implementation of matrix transposition. Note that we
+  // skip the last element since it always has a cycle of length 1 and thus
+  // does not need to be moved.
+  size_t q = matrix->rows * matrix->cols - 1;
+  for (size_t i = 0; i < q; ++i) {
+    if (visited[i] == 1) {
+      continue;
+    }
+    size_t current_idx = i;
+    size_t next_idx = i;
+    do {
+      visited[current_idx] = 1;
+      next_idx = (current_idx * matrix->cols) % q;
+      if (next_idx == i) {
+        break;
+      }
+
+      uint64_t current_val = matrix->data[current_idx];
+      matrix->data[current_idx] = matrix->data[next_idx];
+      matrix->data[next_idx] = current_val;
+      current_idx = next_idx;
+    } while (1);
+  }
+
+  free(visited);
+  size_t cols = matrix->rows;
+  matrix->rows = matrix->cols;
+  matrix->cols = cols;
+}
+
+int matrix_equal(const Matrix* a, const Matrix* b) {
+  if (a == NULL || b == NULL || a->data == NULL || b->data == NULL) {
+    return 0;
+  }
+  if (a->rows != b->rows || a->cols != b->cols) {
+    return 0;
+  }
+  size_t len = a->rows * a->cols;
+  for (size_t i = 0; i < len; ++i) {
+    if (a->data[i] != b->data[i]) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+void matrix_free(Matrix* matrix) {
+  if (matrix == NULL) {
+    return;
+  }
+  if (matrix->data != NULL) {
+    free(matrix->data);
+  }
+  free(matrix);
+}
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.h b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.h
new file mode 100644
index 0000000..40797a2
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix.h
@@ -0,0 +1,48 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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 MATRIX_SRC_MATRIX_H_
+#define MATRIX_SRC_MATRIX_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  size_t rows;
+  size_t cols;
+  uint64_t* data;
+} Matrix;
+
+// Constructs a new Matrix from the given data.
+// Matrix returned contains a copy of the data provided.
+Matrix* matrix_new(size_t rows, size_t cols, const uint64_t* data);
+
+// Fetches the value at the specified row and column.
+// Returns 1 if successful, 0 otherwise.
+int matrix_at(const Matrix* matrix, size_t row, size_t col, uint64_t* n);
+
+// Sets the value at the specified row and column.
+// Returns 1 if successful, 0 otherwise.
+int matrix_set(const Matrix* matrix, size_t row, size_t col, uint64_t n);
+
+// Performs an in-place transposition of the matrix.
+void matrix_transpose(Matrix* matrix);
+
+// Returns 1 if the two matrices are equal, 0 otherwise;
+int matrix_equal(const Matrix* a, const Matrix* b);
+
+// Frees the matrix.
+void matrix_free(Matrix* matrix);
+
+#endif // MATRIX_SRC_MATRIX_H_
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix_test.c b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix_test.c
new file mode 100644
index 0000000..d7bb76b
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/c/matrix_test.c
@@ -0,0 +1,80 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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 "ffi/rust_calling_c/c/matrix.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void matrix_print(const Matrix* m) {
+  for (size_t i = 0; i < m->rows; ++i) {
+    for (size_t j = 0; j < m->cols; ++j) {
+      uint64_t val = 0;
+      matrix_at(m, i, j, &val);
+      printf("%"PRIu64" ", val);
+    }
+    printf("\n");
+  }
+}
+
+int check_equal(const Matrix* a, const Matrix* b) {
+  int equal = matrix_equal(a, b);
+  if (!equal) {
+    printf("Matrices not equal:\n");
+    printf("a:\n");
+    matrix_print(a);
+    printf("\nb:\n");
+    matrix_print(b);
+  }
+  return equal;
+}
+
+void test_equal() {
+  static uint64_t a_data[] = {11, 12, 13, 14,
+                              21, 22, 23, 24};
+  Matrix* a = matrix_new(2, 4, a_data);
+  assert(a != NULL);
+  assert(check_equal(a, a));
+
+  static uint64_t b_data[] = {13, 14, 15, 16,
+                              22, 23, 24, 25};
+  Matrix* b = matrix_new(2, 4, b_data);
+  assert(b != NULL);
+  assert(!matrix_equal(a, b));
+}
+
+void test_transpose() {
+  static uint64_t matrix_data[] = {11, 12, 13, 14,
+                                   21, 22, 23, 24};
+  Matrix* matrix = matrix_new(2, 4, matrix_data);
+  assert(matrix != NULL);
+  matrix_transpose(matrix);
+
+  static uint64_t expected_transpose_data[] = {11, 21,
+                                               12, 22,
+                                               13, 23,
+                                               14, 24};
+  Matrix* expected_transpose = matrix_new(4, 2, expected_transpose_data);
+
+  assert(check_equal(expected_transpose, matrix));
+}
+
+int main(int argc, char** argv) {
+  test_equal();
+  test_transpose();
+  return EXIT_SUCCESS;
+}
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/src/ffi.rs b/third_party/rules_rust/examples/ffi/rust_calling_c/src/ffi.rs
new file mode 100644
index 0000000..4aa6458
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/src/ffi.rs
@@ -0,0 +1,33 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+use libc::{c_int, size_t};
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct Matrix {
+    pub rows: size_t,
+    pub cols: size_t,
+    pub data: *mut u64,
+}
+
+// #[link(name = "native_matrix")] // Don't need this, BUILD file manages linking already.
+extern "C" {
+    pub fn matrix_new(rows: size_t, cols: size_t, data: *const u64) -> *mut Matrix;
+    pub fn matrix_at(matrix: *const Matrix, row: size_t, col: size_t, n: *mut u64) -> c_int;
+    pub fn matrix_set(matrix: *const Matrix, row: size_t, col: size_t, n: u64) -> c_int;
+    pub fn matrix_transpose(matrix: *mut Matrix);
+    pub fn matrix_equal(a: *const Matrix, b: *const Matrix) -> c_int;
+    pub fn matrix_free(matrix: *mut Matrix);
+}
diff --git a/third_party/rules_rust/examples/ffi/rust_calling_c/src/matrix.rs b/third_party/rules_rust/examples/ffi/rust_calling_c/src/matrix.rs
new file mode 100644
index 0000000..9103179
--- /dev/null
+++ b/third_party/rules_rust/examples/ffi/rust_calling_c/src/matrix.rs
@@ -0,0 +1,139 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate libc;
+
+mod ffi;
+
+use std::ops;
+use std::ptr;
+
+/// Wrapper around pointer to FFI Matrix struct.
+pub struct Matrix {
+    matrix: *mut ffi::Matrix,
+}
+
+/// Wrapper around low-level FFI Matrix API.
+impl Matrix {
+    /// Constructs a new Matrix from the given data. Matrix returned contains a copy of the data
+    /// provided.
+    ///
+    /// # Panics
+    ///
+    /// If rows * cols does not equal data.len() or if matrix could not be allocated.
+    pub fn new(rows: usize, cols: usize, data: &[u64]) -> Matrix {
+        if data.len() != rows * cols {
+            panic!(
+                "rows * cols ({}) do not equal data.len() ({})",
+                rows * cols,
+                data.len()
+            );
+        }
+
+        let mut data_copy: Vec<u64> = vec![0; data.len()];
+        data_copy.clone_from_slice(data);
+        unsafe {
+            let matrix: *mut ffi::Matrix = ffi::matrix_new(rows, cols, data_copy.as_ptr());
+            if matrix.is_null() {
+                panic!("Failed to allocate Matrix.");
+            }
+            Matrix { matrix }
+        }
+    }
+
+    /// Fetches the value at the specified row and column.
+    pub fn at(&self, row: usize, col: usize) -> Option<u64> {
+        let mut n: u64 = 0;
+        unsafe {
+            if ffi::matrix_at(self.matrix, row, col, &mut n) == 0 {
+                return None;
+            }
+        }
+        Some(n)
+    }
+
+    /// Sets the value at the specified row and column.
+    ///
+    /// # Panics
+    ///
+    /// If row, col is out of bounds.
+    pub fn set(&mut self, row: usize, col: usize, n: u64) {
+        unsafe {
+            if ffi::matrix_set(self.matrix, row, col, n) == 0 {
+                panic!("Row {}, col {} is out of bounds.", row, col);
+            }
+        }
+    }
+
+    /// Returns the number of rows of the matrix.
+    pub fn rows(&self) -> usize {
+        unsafe { (*self.matrix).rows }
+    }
+
+    /// Returns the number of cols of the matrix.
+    pub fn cols(&self) -> usize {
+        unsafe { (*self.matrix).cols }
+    }
+
+    /// Performs an in-place transposition of the matrix.
+    pub fn transpose(&mut self) {
+        unsafe {
+            ffi::matrix_transpose(self.matrix);
+        }
+    }
+
+    /// Checks whether the matrix is equal to the provided Matrix.
+    pub fn equal(&self, other: &Matrix) -> bool {
+        unsafe { ffi::matrix_equal(self.matrix, other.matrix) != 0 }
+    }
+}
+
+impl ops::Drop for Matrix {
+    fn drop(&mut self) {
+        unsafe {
+            ffi::matrix_free(self.matrix);
+        }
+        self.matrix = ptr::null_mut();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Matrix;
+
+    #[test]
+    fn test_size() {
+        let matrix = Matrix::new(2, 4, &[11, 12, 13, 14, 21, 22, 23, 24]);
+        assert_eq!(2, matrix.rows());
+        assert_eq!(4, matrix.cols());
+    }
+
+    #[test]
+    fn test_equal() {
+        let matrix_a = Matrix::new(2, 4, &[11, 12, 13, 14, 21, 22, 23, 24]);
+        let matrix_b = Matrix::new(2, 4, &[11, 12, 13, 14, 21, 22, 23, 24]);
+        assert!(matrix_a.equal(&matrix_b));
+
+        let matrix_c = Matrix::new(2, 4, &[12, 13, 14, 15, 23, 24, 25, 26]);
+        assert!(!matrix_a.equal(&matrix_c));
+    }
+
+    #[test]
+    fn test_transpose() {
+        let mut matrix = Matrix::new(2, 4, &[11, 12, 13, 14, 21, 22, 23, 24]);
+        matrix.transpose();
+        let expected = Matrix::new(4, 2, &[11, 21, 12, 22, 13, 23, 14, 24]);
+        assert!(matrix.equal(&expected));
+    }
+}
diff --git a/third_party/rules_rust/examples/fibonacci/BUILD.bazel b/third_party/rules_rust/examples/fibonacci/BUILD.bazel
new file mode 100644
index 0000000..87ff5c3
--- /dev/null
+++ b/third_party/rules_rust/examples/fibonacci/BUILD.bazel
@@ -0,0 +1,21 @@
+load("@rules_rust//rust:defs.bzl", "rust_doc", "rust_doc_test", "rust_library", "rust_test")
+
+rust_library(
+    name = "fibonacci",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "fibonacci_test",
+    crate = ":fibonacci",
+)
+
+rust_doc(
+    name = "fibonacci_doc",
+    crate = ":fibonacci",
+)
+
+rust_doc_test(
+    name = "fibonacci_doc_test",
+    crate = ":fibonacci",
+)
diff --git a/third_party/rules_rust/examples/fibonacci/benches/fibonacci_bench.rs b/third_party/rules_rust/examples/fibonacci/benches/fibonacci_bench.rs
new file mode 100644
index 0000000..4a8b721
--- /dev/null
+++ b/third_party/rules_rust/examples/fibonacci/benches/fibonacci_bench.rs
@@ -0,0 +1,25 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+#![feature(test)]
+
+extern crate fibonacci;
+extern crate test;
+
+use test::Bencher;
+
+#[bench]
+fn bench_fibonacci(b: &mut Bencher) {
+    b.iter(|| fibonacci::fibonacci(40));
+}
diff --git a/third_party/rules_rust/examples/fibonacci/src/lib.rs b/third_party/rules_rust/examples/fibonacci/src/lib.rs
new file mode 100644
index 0000000..9645417
--- /dev/null
+++ b/third_party/rules_rust/examples/fibonacci/src/lib.rs
@@ -0,0 +1,47 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+/// Returns the nth Fibonacci number.
+///
+/// # Examples
+///
+/// ```
+/// assert_eq!(fibonacci::fibonacci(5), 5)
+/// ```
+pub fn fibonacci(n: u64) -> u64 {
+    if n < 2 {
+        return n;
+    }
+    let mut n1: u64 = 0;
+    let mut n2: u64 = 1;
+    for _ in 1..n {
+        let sum = n1 + n2;
+        n1 = n2;
+        n2 = sum;
+    }
+    n2
+}
+
+#[cfg(test)]
+mod test {
+    use super::fibonacci;
+
+    #[test]
+    fn test_fibonacci() {
+        let numbers: Vec<u64> = vec![0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144];
+        for (i, number) in numbers.iter().enumerate() {
+            assert_eq!(*number, fibonacci(i as u64));
+        }
+    }
+}
diff --git a/third_party/rules_rust/examples/flag_locations/BUILD.bazel b/third_party/rules_rust/examples/flag_locations/BUILD.bazel
new file mode 100644
index 0000000..fdc92ed
--- /dev/null
+++ b/third_party/rules_rust/examples/flag_locations/BUILD.bazel
@@ -0,0 +1,20 @@
+load("@rules_rust//rust:defs.bzl", "rust_test")
+
+# generate a file containing cfg flags
+genrule(
+    name = "flag_generator",
+    outs = ["generated_flag.data"],
+    cmd = "echo --cfg=test_flag > $@",
+)
+
+rust_test(
+    name = "test",
+    srcs = [
+        "main.rs",
+    ],
+    data = [":flag_generator"],
+    edition = "2018",
+    rustc_flags = [
+        "@$(location :flag_generator)",
+    ],
+)
diff --git a/third_party/rules_rust/examples/flag_locations/main.rs b/third_party/rules_rust/examples/flag_locations/main.rs
new file mode 100644
index 0000000..cee1077
--- /dev/null
+++ b/third_party/rules_rust/examples/flag_locations/main.rs
@@ -0,0 +1,9 @@
+#[test]
+fn test() {
+    // we should be able to read rustc args from a generated file
+    if cfg!(test_flag) {
+        return;
+    }
+
+    unreachable!();
+}
diff --git a/third_party/rules_rust/examples/hello_lib/BUILD.bazel b/third_party/rules_rust/examples/hello_lib/BUILD.bazel
new file mode 100644
index 0000000..e8fb6f6
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_lib/BUILD.bazel
@@ -0,0 +1,73 @@
+load("@rules_rust//rust:defs.bzl", "rust_analyzer", "rust_doc", "rust_doc_test", "rust_library", "rust_shared_library", "rust_static_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+    crate_features = ["default"],
+    rustc_flags = ["--cap-lints=allow"],
+)
+
+rust_shared_library(
+    name = "hello_cdylib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+)
+
+rust_static_library(
+    name = "hello_staticlib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+)
+
+# Regression test for #368: static lib with dependencies fail.
+rust_static_library(
+    name = "hello_test_staticlib",
+    srcs = [
+        "tests/greeting.rs",
+    ],
+    deps = [":hello_lib"],
+)
+
+# Regression test for #368: cdylib lib with dependencies fail.
+rust_shared_library(
+    name = "hello_test_cdylib",
+    srcs = [
+        "tests/greeting.rs",
+    ],
+    deps = [":hello_lib"],
+)
+
+rust_test(
+    name = "hello-lib-test",
+    crate = ":hello_lib",
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+
+rust_doc(
+    name = "hello_lib_doc",
+    crate = ":hello_lib",
+)
+
+rust_doc_test(
+    name = "hello_lib_doc_test",
+    crate = ":hello_lib",
+)
+
+rust_analyzer(
+    name = "hello_rust_analyzer",
+    targets = [":hello_lib"],
+)
diff --git a/third_party/rules_rust/examples/hello_lib/src/greeter.rs b/third_party/rules_rust/examples/hello_lib/src/greeter.rs
new file mode 100644
index 0000000..4a90415
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_lib/src/greeter.rs
@@ -0,0 +1,75 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+/// Object that displays a greeting.
+pub struct Greeter {
+    greeting: String,
+}
+
+/// Implementation of Greeter.
+impl Greeter {
+    /// Constructs a new `Greeter`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// ```
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter {
+            greeting: greeting.to_string(),
+        }
+    }
+
+    /// Returns the greeting as a string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// let greeting = greeter.greeting("World");
+    /// ```
+    pub fn greeting(&self, thing: &str) -> String {
+        format!("{} {}", &self.greeting, thing)
+    }
+
+    /// Prints the greeting.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// greeter.greet("World");
+    /// ```
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Greeter;
+
+    #[test]
+    fn test_greeting() {
+        let hello = Greeter::new("Hi");
+        assert_eq!("Hi Rust", hello.greeting("Rust"));
+    }
+}
diff --git a/third_party/rules_rust/examples/hello_lib/src/lib.rs b/third_party/rules_rust/examples/hello_lib/src/lib.rs
new file mode 100644
index 0000000..9dc6089
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_lib/src/lib.rs
@@ -0,0 +1,15 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+pub mod greeter;
diff --git a/third_party/rules_rust/examples/hello_lib/tests/greeting.rs b/third_party/rules_rust/examples/hello_lib/tests/greeting.rs
new file mode 100644
index 0000000..6084d13
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_lib/tests/greeting.rs
@@ -0,0 +1,27 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate hello_lib;
+
+// test gate is not usually required in an integration test, but the BUILD
+// script is using this file to test cdylib compilation as well, and when
+// compiled in that mode, greeter is an unused import.
+#[cfg(test)]
+use hello_lib::greeter;
+
+#[test]
+fn test_greeting() {
+    let hello = greeter::Greeter::new("Hello");
+    assert_eq!("Hello world", hello.greeting("world"));
+}
diff --git a/third_party/rules_rust/examples/hello_runfiles/BUILD.bazel b/third_party/rules_rust/examples/hello_runfiles/BUILD.bazel
new file mode 100644
index 0000000..64a6c13
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_runfiles/BUILD.bazel
@@ -0,0 +1,25 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "hello_runfiles",
+    srcs = ["hello_runfiles.rs"],
+    data = ["hello_runfiles.rs"],  # Yes, we're being cute.
+    edition = "2018",
+    deps = ["@rules_rust//tools/runfiles"],
+)
diff --git a/third_party/rules_rust/examples/hello_runfiles/hello_runfiles.rs b/third_party/rules_rust/examples/hello_runfiles/hello_runfiles.rs
new file mode 100644
index 0000000..b8a5e45
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_runfiles/hello_runfiles.rs
@@ -0,0 +1,15 @@
+use std::fs::File;
+use std::io::prelude::*;
+
+use runfiles::Runfiles;
+
+fn main() {
+    let r = Runfiles::create().unwrap();
+
+    let mut f = File::open(r.rlocation("examples/hello_runfiles/hello_runfiles.rs")).unwrap();
+
+    let mut buffer = String::new();
+    f.read_to_string(&mut buffer).unwrap();
+
+    println!("This program's source is {} characters long.", buffer.len());
+}
diff --git a/third_party/rules_rust/examples/hello_world/BUILD.bazel b/third_party/rules_rust/examples/hello_world/BUILD.bazel
new file mode 100644
index 0000000..8de8278
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_world/BUILD.bazel
@@ -0,0 +1,14 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_doc")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "hello_world",
+    srcs = ["src/main.rs"],
+    deps = ["@examples//hello_lib"],
+)
+
+rust_doc(
+    name = "hello_world_doc",
+    crate = ":hello_world",
+)
diff --git a/third_party/rules_rust/examples/hello_world/src/main.rs b/third_party/rules_rust/examples/hello_world/src/main.rs
new file mode 100644
index 0000000..03cf43f
--- /dev/null
+++ b/third_party/rules_rust/examples/hello_world/src/main.rs
@@ -0,0 +1,22 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate hello_lib;
+
+use hello_lib::greeter;
+
+fn main() {
+    let hello = greeter::Greeter::new("Hello");
+    hello.greet("world");
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/BUILD.bazel b/third_party/rules_rust/examples/per_platform_printer/BUILD.bazel
new file mode 100644
index 0000000..77b36e4
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/BUILD.bazel
@@ -0,0 +1,41 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "print",
+    srcs = ["main.rs"],
+    deps = [
+        ":printer",
+    ],
+)
+
+rust_library(
+    name = "printer",
+    srcs = [
+        "lib.rs",
+        "print_generic.rs",
+    ] + select({
+        "@rules_rust//rust/platform:linux": [
+            ":print_linux.rs",
+        ],
+        "@rules_rust//rust/platform:macos": [
+            ":print_macos.rs",
+        ],
+        "@rules_rust//rust/platform:windows": [
+            ":print_windows.rs",
+        ],
+    }),
+    # Because each os specific file is conditionally added to the target,
+    # rustfmt does not have all sources to complete formatting. To avoid
+    # this failure, rustfmt is not run on this target
+    tags = ["norustfmt"],
+)
+
+rust_test(
+    name = "printer_test",
+    crate = ":printer",
+    # The same rational used for `printer` applies here. Do not run rustfmt
+    # since not all sources are available.
+    tags = ["norustfmt"],
+)
diff --git a/third_party/rules_rust/examples/per_platform_printer/lib.rs b/third_party/rules_rust/examples/per_platform_printer/lib.rs
new file mode 100644
index 0000000..3ae5ee7
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/lib.rs
@@ -0,0 +1,48 @@
+mod print_generic;
+
+#[cfg(target_os = "linux")]
+mod print_linux;
+
+#[cfg(target_os = "macos")]
+mod print_macos;
+
+#[cfg(target_os = "windows")]
+mod print_windows;
+
+#[cfg(target_os = "linux")]
+pub fn print() -> Vec<String> {
+    vec![print_generic::print(), print_linux::print()]
+}
+
+#[cfg(target_os = "macos")]
+pub fn print() -> Vec<String> {
+    vec![print_generic::print(), print_macos::print()]
+}
+
+#[cfg(target_os = "windows")]
+pub fn print() -> Vec<String> {
+    vec![print_generic::print(), print_windows::print()]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prints_correctly() {
+        let outs = print();
+
+        assert_eq!(
+            outs,
+            vec![
+                "Hello Generic!",
+                #[cfg(target_os = "linux")]
+                "Hello Linux!",
+                #[cfg(target_os = "macos")]
+                "Hello MacOS!",
+                #[cfg(target_os = "windows")]
+                "Hello Windows!",
+            ]
+        );
+    }
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/main.rs b/third_party/rules_rust/examples/per_platform_printer/main.rs
new file mode 100644
index 0000000..53e58cb
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/main.rs
@@ -0,0 +1,5 @@
+extern crate printer;
+
+fn main() {
+    printer::print();
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/print_generic.rs b/third_party/rules_rust/examples/per_platform_printer/print_generic.rs
new file mode 100644
index 0000000..1144b59
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/print_generic.rs
@@ -0,0 +1,3 @@
+pub fn print() -> String {
+    "Hello Generic!".to_owned()
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/print_linux.rs b/third_party/rules_rust/examples/per_platform_printer/print_linux.rs
new file mode 100644
index 0000000..d1740bd
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/print_linux.rs
@@ -0,0 +1,3 @@
+pub fn print() -> String {
+    "Hello Linux!".to_owned()
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/print_macos.rs b/third_party/rules_rust/examples/per_platform_printer/print_macos.rs
new file mode 100644
index 0000000..965f787
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/print_macos.rs
@@ -0,0 +1,3 @@
+pub fn print() -> String {
+    "Hello MacOS!".to_owned()
+}
diff --git a/third_party/rules_rust/examples/per_platform_printer/print_windows.rs b/third_party/rules_rust/examples/per_platform_printer/print_windows.rs
new file mode 100644
index 0000000..b857dcb
--- /dev/null
+++ b/third_party/rules_rust/examples/per_platform_printer/print_windows.rs
@@ -0,0 +1,3 @@
+pub fn print() -> String {
+    "Hello Windows!".to_owned()
+}
diff --git a/third_party/rules_rust/examples/proc_macro/BUILD.bazel b/third_party/rules_rust/examples/proc_macro/BUILD.bazel
new file mode 100644
index 0000000..2f49c4d
--- /dev/null
+++ b/third_party/rules_rust/examples/proc_macro/BUILD.bazel
@@ -0,0 +1,47 @@
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_doc",
+    "rust_doc_test",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+rust_proc_macro(
+    name = "proc_macro_lib_2015",
+    srcs = [
+        "src/lib_2015.rs",
+    ],
+)
+
+rust_proc_macro(
+    name = "proc_macro_lib",
+    srcs = [
+        "src/lib.rs",
+    ],
+    edition = "2018",
+)
+
+rust_test(
+    name = "proc_macro_test",
+    crate = ":proc_macro_lib",
+    edition = "2018",
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    edition = "2018",
+    proc_macro_deps = [":proc_macro_lib"],
+)
+
+rust_doc(
+    name = "proc_macro_lib_doc",
+    crate = ":proc_macro_lib",
+)
+
+rust_doc_test(
+    name = "doc_test",
+    crate = ":proc_macro_lib",
+)
diff --git a/third_party/rules_rust/examples/proc_macro/src/lib.rs b/third_party/rules_rust/examples/proc_macro/src/lib.rs
new file mode 100644
index 0000000..87b9d47
--- /dev/null
+++ b/third_party/rules_rust/examples/proc_macro/src/lib.rs
@@ -0,0 +1,25 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+// This differs from the edition 2015 version because it does not have an `extern proc_macro`
+// statement, which became optional in edition 2018.
+
+use proc_macro::TokenStream;
+
+/// This macro is a no-op; it is exceedingly simple as a result
+/// of avoiding dependencies on both the syn and quote crates.
+#[proc_macro_derive(HelloWorld)]
+pub fn hello_world(_input: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
diff --git a/third_party/rules_rust/examples/proc_macro/src/lib_2015.rs b/third_party/rules_rust/examples/proc_macro/src/lib_2015.rs
new file mode 100644
index 0000000..b74e5c5
--- /dev/null
+++ b/third_party/rules_rust/examples/proc_macro/src/lib_2015.rs
@@ -0,0 +1,24 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+/// This macro is a no-op; it is exceedingly simple as a result
+/// of avoiding dependencies on both the syn and quote crates.
+#[proc_macro_derive(HelloWorld)]
+pub fn hello_world(_input: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
diff --git a/third_party/rules_rust/examples/proc_macro/tests/greeting.rs b/third_party/rules_rust/examples/proc_macro/tests/greeting.rs
new file mode 100644
index 0000000..e58b639
--- /dev/null
+++ b/third_party/rules_rust/examples/proc_macro/tests/greeting.rs
@@ -0,0 +1,23 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+use proc_macro_lib::HelloWorld;
+
+#[derive(HelloWorld)]
+struct TestStruct {}
+
+#[test]
+fn test_hello_world_macro() {
+    let _ = TestStruct {};
+}
diff --git a/third_party/rules_rust/examples/proto/BUILD.bazel b/third_party/rules_rust/examples/proto/BUILD.bazel
new file mode 100644
index 0000000..9ddf0e3
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/BUILD.bazel
@@ -0,0 +1,8 @@
+load("@rules_proto//proto:defs.bzl", "proto_library")
+
+package(default_visibility = ["//proto:__subpackages__"])
+
+proto_library(
+    name = "common",
+    srcs = ["common.proto"],
+)
diff --git a/third_party/rules_rust/examples/proto/basic/BUILD.bazel b/third_party/rules_rust/examples/proto/basic/BUILD.bazel
new file mode 100644
index 0000000..9853a2e
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/basic/BUILD.bazel
@@ -0,0 +1,24 @@
+load("@rules_rust//proto:proto.bzl", "rust_proto_library")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
+
+package(default_visibility = ["//proto:__subpackages__"])
+
+rust_proto_library(
+    name = "common_proto_rust",
+    deps = ["//proto:common"],
+)
+
+rust_library(
+    name = "common_lib",
+    srcs = ["lib.rs"],
+    deps = [":common_proto_rust"],
+)
+
+rust_binary(
+    name = "common_bin",
+    srcs = ["main.rs"],
+    deps = [
+        ":common_lib",
+        ":common_proto_rust",
+    ],
+)
diff --git a/third_party/rules_rust/examples/proto/basic/lib.rs b/third_party/rules_rust/examples/proto/basic/lib.rs
new file mode 100644
index 0000000..2146b3c
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/basic/lib.rs
@@ -0,0 +1,5 @@
+extern crate common_proto_rust;
+
+pub fn do_something(_x: &common_proto_rust::Config) -> bool {
+    true
+}
diff --git a/third_party/rules_rust/examples/proto/basic/main.rs b/third_party/rules_rust/examples/proto/basic/main.rs
new file mode 100644
index 0000000..12ed82f
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/basic/main.rs
@@ -0,0 +1,6 @@
+extern crate common_lib;
+extern crate common_proto_rust;
+
+pub fn main() {
+    common_lib::do_something(&common_proto_rust::Config::new());
+}
diff --git a/third_party/rules_rust/examples/proto/common.proto b/third_party/rules_rust/examples/proto/common.proto
new file mode 100644
index 0000000..56bac18
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/common.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+option java_package = "org.pubref.rules_protobuf.examples";
+option java_outer_classname = "CommonProto";
+
+package common;
+
+// A configuration object.  This is used to test the viability of
+// protobuf imports.
+message Config {
+  bool verbose = 1;
+}
+
diff --git a/third_party/rules_rust/examples/proto/helloworld/BUILD.bazel b/third_party/rules_rust/examples/proto/helloworld/BUILD.bazel
new file mode 100644
index 0000000..db30a9d
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/BUILD.bazel
@@ -0,0 +1,25 @@
+load("@rules_proto//proto:defs.bzl", "proto_library")
+load("@rules_rust//proto:proto.bzl", "rust_grpc_library")
+load("@rules_rust//rust:defs.bzl", "rust_test")
+
+proto_library(
+    name = "helloworld",
+    srcs = ["helloworld.proto"],
+    deps = ["//proto:common"],
+)
+
+rust_grpc_library(
+    name = "helloworld_proto",
+    visibility = ["//proto/helloworld:__subpackages__"],
+    deps = [":helloworld"],
+)
+
+rust_test(
+    name = "helloworld_test",
+    srcs = ["helloworld_test.rs"],
+    data = [
+        "//proto/helloworld/greeter_client",
+        "//proto/helloworld/greeter_server",
+    ],
+    deps = ["@rules_rust//tools/runfiles"],
+)
diff --git a/third_party/rules_rust/examples/proto/helloworld/greeter_client/BUILD.bazel b/third_party/rules_rust/examples/proto/helloworld/greeter_client/BUILD.bazel
new file mode 100644
index 0000000..b35435e
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/greeter_client/BUILD.bazel
@@ -0,0 +1,11 @@
+load("@rules_rust//proto:toolchain.bzl", "GRPC_COMPILE_DEPS")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+rust_binary(
+    name = "greeter_client",
+    srcs = ["greeter_client.rs"],
+    visibility = ["//proto/helloworld:__subpackages__"],
+    deps = [
+        "//proto/helloworld:helloworld_proto",
+    ] + GRPC_COMPILE_DEPS,
+)
diff --git a/third_party/rules_rust/examples/proto/helloworld/greeter_client/greeter_client.rs b/third_party/rules_rust/examples/proto/helloworld/greeter_client/greeter_client.rs
new file mode 100644
index 0000000..ade62eb
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/greeter_client/greeter_client.rs
@@ -0,0 +1,44 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate grpc;
+extern crate helloworld_proto;
+
+use grpc::ClientStubExt;
+use std::env;
+use std::str::FromStr;
+
+use helloworld_proto::*;
+
+fn parse_args() -> (String, u16) {
+    let mut name = "world".to_owned();
+    let mut port = 50051;
+    for arg in env::args().skip(1) {
+        if let Some(argp) = arg.strip_prefix("-p=") {
+            port = u16::from_str(argp).unwrap()
+        } else {
+            name = arg.to_owned();
+        }
+    }
+    (name, port)
+}
+
+fn main() {
+    let (name, port) = parse_args();
+    let client = GreeterClient::new_plain("::1", port, Default::default()).unwrap();
+    let mut req = HelloRequest::new();
+    req.set_name(name);
+    let resp = client.say_hello(grpc::RequestOptions::new(), req);
+    println!("{:?}", resp.wait());
+}
diff --git a/third_party/rules_rust/examples/proto/helloworld/greeter_server/BUILD.bazel b/third_party/rules_rust/examples/proto/helloworld/greeter_server/BUILD.bazel
new file mode 100644
index 0000000..616ecb5
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/greeter_server/BUILD.bazel
@@ -0,0 +1,11 @@
+load("@rules_rust//proto:toolchain.bzl", "GRPC_COMPILE_DEPS")
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+rust_binary(
+    name = "greeter_server",
+    srcs = ["greeter_server.rs"],
+    visibility = ["//proto/helloworld:__subpackages__"],
+    deps = [
+        "//proto/helloworld:helloworld_proto",
+    ] + GRPC_COMPILE_DEPS,
+)
diff --git a/third_party/rules_rust/examples/proto/helloworld/greeter_server/greeter_server.rs b/third_party/rules_rust/examples/proto/helloworld/greeter_server/greeter_server.rs
new file mode 100644
index 0000000..17a09a1
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/greeter_server/greeter_server.rs
@@ -0,0 +1,58 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate grpc;
+extern crate helloworld_proto;
+extern crate tls_api_stub;
+
+use std::env;
+use std::str::FromStr;
+use std::thread;
+
+use helloworld_proto::*;
+
+struct GreeterImpl;
+
+impl Greeter for GreeterImpl {
+    fn say_hello(
+        &self,
+        _m: grpc::RequestOptions,
+        req: HelloRequest,
+    ) -> grpc::SingleResponse<HelloReply> {
+        let mut r = HelloReply::new();
+        let name = if req.get_name().is_empty() {
+            "world"
+        } else {
+            req.get_name()
+        };
+        println!("greeting request from {}", name);
+        r.set_message(format!("Hello {}", name));
+        grpc::SingleResponse::completed(r)
+    }
+}
+
+fn main() {
+    let mut server = grpc::ServerBuilder::<tls_api_stub::TlsAcceptor>::new();
+    let port = u16::from_str(&env::args().nth(1).unwrap_or_else(|| "50051".to_owned())).unwrap();
+    server.http.set_port(port);
+    server.add_service(GreeterServer::new_service_def(GreeterImpl));
+    server.http.set_cpu_pool_threads(4);
+    let server = server.build().expect("server");
+    let port = server.local_addr().port().unwrap();
+    println!("greeter server started on port {}", port);
+
+    loop {
+        thread::park();
+    }
+}
diff --git a/third_party/rules_rust/examples/proto/helloworld/helloworld.proto b/third_party/rules_rust/examples/proto/helloworld/helloworld.proto
new file mode 100644
index 0000000..e0c7598
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/helloworld.proto
@@ -0,0 +1,23 @@
+
+syntax = "proto3";
+
+import "proto/common.proto";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+  common.Config config = 2;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/third_party/rules_rust/examples/proto/helloworld/helloworld_test.rs b/third_party/rules_rust/examples/proto/helloworld/helloworld_test.rs
new file mode 100644
index 0000000..c82e474
--- /dev/null
+++ b/third_party/rules_rust/examples/proto/helloworld/helloworld_test.rs
@@ -0,0 +1,109 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+// Integration tests for the greeter client/server
+extern crate runfiles;
+
+use std::io::BufRead;
+use std::io::BufReader;
+use std::process::{Child, Command, Stdio};
+use std::str::FromStr;
+
+use runfiles::Runfiles;
+
+struct ServerInfo {
+    process: Child,
+    port: u16,
+}
+
+macro_rules! assert_contains {
+    ($s: expr, $e: expr) => {
+        assert!($s.find($e).is_some());
+    };
+}
+
+impl ServerInfo {
+    fn new() -> ServerInfo {
+        let r = Runfiles::create().unwrap();
+        let mut c =
+            Command::new(r.rlocation("examples/proto/helloworld/greeter_server/greeter_server"))
+                .arg("0")
+                .stdout(Stdio::piped())
+                .spawn()
+                .expect("Unable to start server");
+        let mut port: u16 = 0;
+        {
+            let mut stdout = BufReader::new(c.stdout.as_mut().expect("Failed to open stdout"));
+            let port_prefix = "greeter server started on port ";
+            while port == 0 {
+                let mut line = String::new();
+                stdout
+                    .read_line(&mut line)
+                    .expect("Waiting for server startup");
+                line = line.trim().to_owned();
+                if let Some(argp) = line.strip_prefix(port_prefix) {
+                    port = u16::from_str(argp)
+                        .unwrap_or_else(|_| panic!("Invalid port number {}", argp))
+                }
+            }
+        }
+        println!("Started server on port {}", port);
+        ServerInfo { process: c, port }
+    }
+
+    fn run_client_impl(&self, arg: Option<String>) -> String {
+        let r = Runfiles::create().unwrap();
+
+        let mut cmd0 =
+            Command::new(r.rlocation("examples/proto/helloworld/greeter_client/greeter_client"));
+        let cmd = cmd0.arg(format!("-p={}", self.port));
+
+        let output = if let Some(s) = arg { cmd.arg(s) } else { cmd }
+            .output()
+            .expect("Unable to start client");
+        assert!(output.status.success());
+        String::from_utf8(output.stdout).expect("Non UTF-8 output from the client")
+    }
+
+    fn run_client(&self) -> String {
+        self.run_client_impl(None)
+    }
+    fn run_client_with_arg(&self, arg: &str) -> String {
+        self.run_client_impl(Some(arg.to_owned()))
+    }
+
+    fn expect_log(&mut self, log: &str) {
+        let mut reader =
+            BufReader::new(self.process.stdout.as_mut().expect("Failed to open stdout"));
+        let mut line = String::new();
+        reader
+            .read_line(&mut line)
+            .expect("Failed to read line from the server");
+        assert_contains!(line, log);
+    }
+
+    fn destroy(&mut self) {
+        self.process.kill().unwrap();
+    }
+}
+
+#[test]
+fn test_client_server() {
+    let mut s = ServerInfo::new();
+    assert_contains!(s.run_client(), "message: \"Hello world\"");
+    s.expect_log("greeting request from world");
+    assert_contains!(s.run_client_with_arg("thou"), "message: \"Hello thou\"");
+    s.expect_log("greeting request from thou");
+    s.destroy();
+}
diff --git a/third_party/rules_rust/examples/sys/BUILD.bazel b/third_party/rules_rust/examples/sys/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/BUILD.bazel
diff --git a/third_party/rules_rust/examples/sys/basic/BUILD.bazel b/third_party/rules_rust/examples/sys/basic/BUILD.bazel
new file mode 100644
index 0000000..142aa89
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/BUILD.bazel
@@ -0,0 +1,33 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "hello_sys",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+    # Note the `cargo-raze` dependencies here need to have been loaded
+    # in the WORKSPACE file. See `//sys:sys_deps.bzl` for rmore details.
+    deps = ["//sys/basic/raze:bzip2"],
+)
+
+sh_test(
+    name = "test",
+    srcs = ["test.sh"],
+    args = ["$(location :hello_sys)"],
+    data = [":hello_sys"],
+)
diff --git a/third_party/rules_rust/examples/sys/basic/Cargo.lock b/third_party/rules_rust/examples/sys/basic/Cargo.lock
new file mode 100644
index 0000000..7a14e37
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/Cargo.lock
@@ -0,0 +1,47 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "bzip2"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42b7c3cbf0fa9c1b82308d57191728ca0256cb821220f4e2fd410a72ade26e3b"
+dependencies = [
+ "bzip2-sys",
+ "libc",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.9+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad3b39a260062fca31f7b0b12f207e8f2590a67d32ec7d59c20484b07ea7285e"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef611cc68ff783f18535d77ddd080185275713d852c4f5cbb6122c462a7a825c"
+
+[[package]]
+name = "libc"
+version = "0.2.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
+
+[[package]]
+name = "rules_rust_examples_basic_sys"
+version = "0.0.1"
+dependencies = [
+ "bzip2",
+]
diff --git a/third_party/rules_rust/examples/sys/basic/Cargo.toml b/third_party/rules_rust/examples/sys/basic/Cargo.toml
new file mode 100644
index 0000000..61b97fc
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "rules_rust_examples_basic_sys"
+version = "0.0.1"
+
+[[bin]]
+name = "rules_rust_examples_basic_sys"
+path = "src/main.rs"
+
+[dependencies]
+bzip2 = "=0.3.3"
+
+[package.metadata.raze]
+workspace_path = "//sys/basic/raze"
+genmode = "Remote"
+gen_workspace_prefix = "basic_sys"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "raze"
+default_gen_buildrs = false
+
+[package.metadata.raze.crates.bzip2-sys.'0.1.9+1.0.8']
+gen_buildrs = true
diff --git a/third_party/rules_rust/examples/sys/basic/raze/BUILD.bazel b/third_party/rules_rust/examples/sys/basic/raze/BUILD.bazel
new file mode 100644
index 0000000..ade3349
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/BUILD.bazel
@@ -0,0 +1,30 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "bzip2",
+    actual = "@basic_sys__bzip2__0_3_3//:bzip2",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/sys/basic/raze/crates.bzl b/third_party/rules_rust/examples/sys/basic/raze/crates.bzl
new file mode 100644
index 0000000..beacc3e
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/crates.bzl
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def basic_sys_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "basic_sys__bzip2__0_3_3",
+        url = "https://crates.io/api/v1/crates/bzip2/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "42b7c3cbf0fa9c1b82308d57191728ca0256cb821220f4e2fd410a72ade26e3b",
+        strip_prefix = "bzip2-0.3.3",
+        build_file = Label("//sys/basic/raze/remote:BUILD.bzip2-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "basic_sys__bzip2_sys__0_1_9_1_0_8",
+        url = "https://crates.io/api/v1/crates/bzip2-sys/0.1.9+1.0.8/download",
+        type = "tar.gz",
+        sha256 = "ad3b39a260062fca31f7b0b12f207e8f2590a67d32ec7d59c20484b07ea7285e",
+        strip_prefix = "bzip2-sys-0.1.9+1.0.8",
+        build_file = Label("//sys/basic/raze/remote:BUILD.bzip2-sys-0.1.9+1.0.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "basic_sys__cc__1_0_60",
+        url = "https://crates.io/api/v1/crates/cc/1.0.60/download",
+        type = "tar.gz",
+        sha256 = "ef611cc68ff783f18535d77ddd080185275713d852c4f5cbb6122c462a7a825c",
+        strip_prefix = "cc-1.0.60",
+        build_file = Label("//sys/basic/raze/remote:BUILD.cc-1.0.60.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "basic_sys__libc__0_2_77",
+        url = "https://crates.io/api/v1/crates/libc/0.2.77/download",
+        type = "tar.gz",
+        sha256 = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235",
+        strip_prefix = "libc-0.2.77",
+        build_file = Label("//sys/basic/raze/remote:BUILD.libc-0.2.77.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "basic_sys__pkg_config__0_3_18",
+        url = "https://crates.io/api/v1/crates/pkg-config/0.3.18/download",
+        type = "tar.gz",
+        sha256 = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33",
+        strip_prefix = "pkg-config-0.3.18",
+        build_file = Label("//sys/basic/raze/remote:BUILD.pkg-config-0.3.18.bazel"),
+    )
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-0.3.3.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-0.3.3.bazel
new file mode 100644
index 0000000..403de65
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-0.3.3.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/basic/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "bzip2",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+        "@basic_sys__bzip2_sys__0_1_9_1_0_8//:bzip2_sys",
+        "@basic_sys__libc__0_2_77//:libc",
+    ],
+)
+
+# Unsupported target "tokio" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-sys-0.1.9+1.0.8.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-sys-0.1.9+1.0.8.bazel
new file mode 100644
index 0000000..2401d2c
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.bzip2-sys-0.1.9+1.0.8.bazel
@@ -0,0 +1,87 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/basic/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "bzip2_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    links = "bzip2",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.9+1.0.8",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@basic_sys__cc__1_0_60//:cc",
+        "@basic_sys__pkg_config__0_3_18//:pkg_config",
+    ],
+)
+
+rust_library(
+    name = "bzip2_sys",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.9+1.0.8",
+    # buildifier: leave-alone
+    deps = [
+        ":bzip2_sys_build_script",
+        "@basic_sys__libc__0_2_77//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.cc-1.0.60.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.cc-1.0.60.bazel
new file mode 100644
index 0000000..ad826c1
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.cc-1.0.60.bazel
@@ -0,0 +1,85 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/basic/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_gcc_shim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/gcc-shim.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.60",
+    # buildifier: leave-alone
+    deps = [
+        ":cc",
+    ],
+)
+
+rust_library(
+    name = "cc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.60",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "cc_env" with type "test" omitted
+
+# Unsupported target "cflags" with type "test" omitted
+
+# Unsupported target "cxxflags" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.libc-0.2.77.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.libc-0.2.77.bazel
new file mode 100644
index 0000000..4b8aed7
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.libc-0.2.77.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/basic/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.77",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.pkg-config-0.3.18.bazel b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.pkg-config-0.3.18.bazel
new file mode 100644
index 0000000..0121432
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/raze/remote/BUILD.pkg-config-0.3.18.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/basic/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "pkg_config",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.18",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/basic/src/main.rs b/third_party/rules_rust/examples/sys/basic/src/main.rs
new file mode 100644
index 0000000..a02bdb0
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/src/main.rs
@@ -0,0 +1,42 @@
+use bzip2::read::BzEncoder;
+use bzip2::Compression;
+use std::io::Read;
+
+fn main() {
+    let stdin = std::io::stdin();
+    let stdin = stdin.lock();
+    let mut raw_counter = CountingStream::new(stdin);
+
+    let compressed_count = {
+        let compressor = BzEncoder::new(&mut raw_counter, Compression::Best);
+        let mut compressed_counter = CountingStream::new(compressor);
+        std::io::copy(&mut compressed_counter, &mut std::io::sink()).unwrap();
+        compressed_counter.count
+    };
+
+    println!(
+        "Compressed {} to {} bytes",
+        raw_counter.count, compressed_count
+    );
+}
+
+struct CountingStream<R: Read> {
+    stream: R,
+    count: usize,
+}
+
+impl<R: Read> CountingStream<R> {
+    fn new(stream: R) -> Self {
+        CountingStream { stream, count: 0 }
+    }
+}
+
+impl<R: Read> Read for CountingStream<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let result = self.stream.read(buf);
+        if let Ok(read_bytes) = result {
+            self.count += read_bytes;
+        }
+        result
+    }
+}
diff --git a/third_party/rules_rust/examples/sys/basic/test.sh b/third_party/rules_rust/examples/sys/basic/test.sh
new file mode 100755
index 0000000..b2aa8e0
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/basic/test.sh
@@ -0,0 +1,5 @@
+#!/bin/bash -eu
+
+out="$(echo -n "Hello world" | "$1")"
+
+[[ "${out}" == "Compressed 11 to 50 bytes" ]] || (echo "Got ${out}" && exit 1)
diff --git a/third_party/rules_rust/examples/sys/complex/BUILD.bazel b/third_party/rules_rust/examples/sys/complex/BUILD.bazel
new file mode 100644
index 0000000..f0e7f0b
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/BUILD.bazel
@@ -0,0 +1,26 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "complex_sys",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+    # Note the `cargo-raze` dependencies here need to have been loaded
+    # in the WORKSPACE file. See `//sys:sys_deps.bzl` for rmore details.
+    deps = ["//sys/complex/raze:git2"],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/Cargo.lock b/third_party/rules_rust/examples/sys/complex/Cargo.lock
new file mode 100644
index 0000000..a2676c7
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/Cargo.lock
@@ -0,0 +1,260 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+
+[[package]]
+name = "cc"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+dependencies = [
+ "jobserver",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+dependencies = [
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "git2"
+version = "0.13.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca6f1a0238d7f8f8fd5ee642f4ebac4dbc03e03d1f78fbe7a3ede35dcf7e2224"
+dependencies = [
+ "bitflags",
+ "libc",
+ "libgit2-sys",
+ "log",
+ "openssl-probe",
+ "openssl-sys",
+ "url",
+]
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5ca711fd837261e14ec9e674f092cbb931d3fa1482b017ae59328ddc6f3212b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790"
+
+[[package]]
+name = "libgit2-sys"
+version = "0.12.21+1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86271bacd72b2b9e854c3dcfb82efd538f15f870e4c11af66900effb462f6825"
+dependencies = [
+ "cc",
+ "libc",
+ "libssh2-sys",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+]
+
+[[package]]
+name = "libssh2-sys"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0186af0d8f171ae6b9c4c90ec51898bad5d08a2d5e470903a50d9ad8959cbee"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
+
+[[package]]
+name = "openssl"
+version = "0.10.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "038d43985d1ddca7a9900630d8cd031b56e4794eecc2e9ea39dd17aa04399a70"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "lazy_static",
+ "libc",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "921fc71883267538946025deffb622905ecad223c28efbfdef9bb59a0175f3e6"
+dependencies = [
+ "autocfg",
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
+
+[[package]]
+name = "rules_rust_examples_complex_sys"
+version = "0.0.1"
+dependencies = [
+ "git2",
+ "openssl",
+ "openssl-sys",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeb8be209bb1c96b7c177c7420d26e04eccacb0eeae6b980e35fcb74678107e0"
+dependencies = [
+ "matches",
+]
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "url"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
diff --git a/third_party/rules_rust/examples/sys/complex/Cargo.toml b/third_party/rules_rust/examples/sys/complex/Cargo.toml
new file mode 100644
index 0000000..1e47fb4
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "rules_rust_examples_complex_sys"
+version = "0.0.1"
+
+[[bin]]
+name = "rules_rust_examples_complex_sys"
+path = "src/main.rs"
+
+[dependencies]
+git2 = "=0.13.12"
+openssl = "=0.10.32"
+openssl-sys = "=0.9.60"
+
+[package.metadata.raze]
+workspace_path = "//sys/complex/raze"
+genmode = "Remote"
+gen_workspace_prefix = "complex_sys"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "raze"
+default_gen_buildrs = true
+
+[package.metadata.raze.crates.openssl-sys.'*']
+# build.rs file: https://github.com/sfackler/rust-openssl/blob/master/openssl-sys/build/main.rs
+build_data_dependencies = [
+    "@openssl//:openssl",
+    "@openssl//:gen_dir",
+]
+data_attr = "[\"@openssl//:openssl\"]"
+additional_deps = ["@openssl//:openssl"]
+    [package.metadata.raze.crates.openssl-sys.'*'.buildrs_additional_environment_variables]
+        OPENSSL_DIR="$(execpath @openssl//:gen_dir)"
+        OPENSSL_STATIC="1"
+
+[package.metadata.raze.crates.libssh2-sys.'0.2.20']
+build_data_dependencies = ["@openssl"]
diff --git a/third_party/rules_rust/examples/sys/complex/raze/BUILD.bazel b/third_party/rules_rust/examples/sys/complex/raze/BUILD.bazel
new file mode 100644
index 0000000..f718efb
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/BUILD.bazel
@@ -0,0 +1,48 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "git2",
+    actual = "@complex_sys__git2__0_13_12//:git2",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "openssl",
+    actual = "@complex_sys__openssl__0_10_32//:openssl",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "openssl_sys",
+    actual = "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/crates.bzl b/third_party/rules_rust/examples/sys/complex/raze/crates.bzl
new file mode 100644
index 0000000..a8ccc94
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/crates.bzl
@@ -0,0 +1,292 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def complex_sys_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "complex_sys__autocfg__1_0_1",
+        url = "https://crates.io/api/v1/crates/autocfg/1.0.1/download",
+        type = "tar.gz",
+        sha256 = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a",
+        strip_prefix = "autocfg-1.0.1",
+        build_file = Label("//sys/complex/raze/remote:BUILD.autocfg-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__bitflags__1_2_1",
+        url = "https://crates.io/api/v1/crates/bitflags/1.2.1/download",
+        type = "tar.gz",
+        sha256 = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693",
+        strip_prefix = "bitflags-1.2.1",
+        build_file = Label("//sys/complex/raze/remote:BUILD.bitflags-1.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__cc__1_0_69",
+        url = "https://crates.io/api/v1/crates/cc/1.0.69/download",
+        type = "tar.gz",
+        sha256 = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2",
+        strip_prefix = "cc-1.0.69",
+        build_file = Label("//sys/complex/raze/remote:BUILD.cc-1.0.69.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__cfg_if__1_0_0",
+        url = "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("//sys/complex/raze/remote:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__foreign_types__0_3_2",
+        url = "https://crates.io/api/v1/crates/foreign-types/0.3.2/download",
+        type = "tar.gz",
+        sha256 = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1",
+        strip_prefix = "foreign-types-0.3.2",
+        build_file = Label("//sys/complex/raze/remote:BUILD.foreign-types-0.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__foreign_types_shared__0_1_1",
+        url = "https://crates.io/api/v1/crates/foreign-types-shared/0.1.1/download",
+        type = "tar.gz",
+        sha256 = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b",
+        strip_prefix = "foreign-types-shared-0.1.1",
+        build_file = Label("//sys/complex/raze/remote:BUILD.foreign-types-shared-0.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__form_urlencoded__1_0_1",
+        url = "https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download",
+        type = "tar.gz",
+        sha256 = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191",
+        strip_prefix = "form_urlencoded-1.0.1",
+        build_file = Label("//sys/complex/raze/remote:BUILD.form_urlencoded-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__git2__0_13_12",
+        url = "https://crates.io/api/v1/crates/git2/0.13.12/download",
+        type = "tar.gz",
+        sha256 = "ca6f1a0238d7f8f8fd5ee642f4ebac4dbc03e03d1f78fbe7a3ede35dcf7e2224",
+        strip_prefix = "git2-0.13.12",
+        build_file = Label("//sys/complex/raze/remote:BUILD.git2-0.13.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__idna__0_2_3",
+        url = "https://crates.io/api/v1/crates/idna/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8",
+        strip_prefix = "idna-0.2.3",
+        build_file = Label("//sys/complex/raze/remote:BUILD.idna-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__jobserver__0_1_23",
+        url = "https://crates.io/api/v1/crates/jobserver/0.1.23/download",
+        type = "tar.gz",
+        sha256 = "f5ca711fd837261e14ec9e674f092cbb931d3fa1482b017ae59328ddc6f3212b",
+        strip_prefix = "jobserver-0.1.23",
+        build_file = Label("//sys/complex/raze/remote:BUILD.jobserver-0.1.23.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//sys/complex/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__libc__0_2_98",
+        url = "https://crates.io/api/v1/crates/libc/0.2.98/download",
+        type = "tar.gz",
+        sha256 = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790",
+        strip_prefix = "libc-0.2.98",
+        build_file = Label("//sys/complex/raze/remote:BUILD.libc-0.2.98.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__libgit2_sys__0_12_21_1_1_0",
+        url = "https://crates.io/api/v1/crates/libgit2-sys/0.12.21+1.1.0/download",
+        type = "tar.gz",
+        sha256 = "86271bacd72b2b9e854c3dcfb82efd538f15f870e4c11af66900effb462f6825",
+        strip_prefix = "libgit2-sys-0.12.21+1.1.0",
+        build_file = Label("//sys/complex/raze/remote:BUILD.libgit2-sys-0.12.21+1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__libssh2_sys__0_2_21",
+        url = "https://crates.io/api/v1/crates/libssh2-sys/0.2.21/download",
+        type = "tar.gz",
+        sha256 = "e0186af0d8f171ae6b9c4c90ec51898bad5d08a2d5e470903a50d9ad8959cbee",
+        strip_prefix = "libssh2-sys-0.2.21",
+        build_file = Label("//sys/complex/raze/remote:BUILD.libssh2-sys-0.2.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__libz_sys__1_1_3",
+        url = "https://crates.io/api/v1/crates/libz-sys/1.1.3/download",
+        type = "tar.gz",
+        sha256 = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66",
+        strip_prefix = "libz-sys-1.1.3",
+        build_file = Label("//sys/complex/raze/remote:BUILD.libz-sys-1.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__log__0_4_14",
+        url = "https://crates.io/api/v1/crates/log/0.4.14/download",
+        type = "tar.gz",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        strip_prefix = "log-0.4.14",
+        build_file = Label("//sys/complex/raze/remote:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__matches__0_1_8",
+        url = "https://crates.io/api/v1/crates/matches/0.1.8/download",
+        type = "tar.gz",
+        sha256 = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08",
+        strip_prefix = "matches-0.1.8",
+        build_file = Label("//sys/complex/raze/remote:BUILD.matches-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__openssl__0_10_32",
+        url = "https://crates.io/api/v1/crates/openssl/0.10.32/download",
+        type = "tar.gz",
+        sha256 = "038d43985d1ddca7a9900630d8cd031b56e4794eecc2e9ea39dd17aa04399a70",
+        strip_prefix = "openssl-0.10.32",
+        build_file = Label("//sys/complex/raze/remote:BUILD.openssl-0.10.32.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__openssl_probe__0_1_4",
+        url = "https://crates.io/api/v1/crates/openssl-probe/0.1.4/download",
+        type = "tar.gz",
+        sha256 = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a",
+        strip_prefix = "openssl-probe-0.1.4",
+        build_file = Label("//sys/complex/raze/remote:BUILD.openssl-probe-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__openssl_sys__0_9_60",
+        url = "https://crates.io/api/v1/crates/openssl-sys/0.9.60/download",
+        type = "tar.gz",
+        sha256 = "921fc71883267538946025deffb622905ecad223c28efbfdef9bb59a0175f3e6",
+        strip_prefix = "openssl-sys-0.9.60",
+        build_file = Label("//sys/complex/raze/remote:BUILD.openssl-sys-0.9.60.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__percent_encoding__2_1_0",
+        url = "https://crates.io/api/v1/crates/percent-encoding/2.1.0/download",
+        type = "tar.gz",
+        sha256 = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e",
+        strip_prefix = "percent-encoding-2.1.0",
+        build_file = Label("//sys/complex/raze/remote:BUILD.percent-encoding-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__pkg_config__0_3_19",
+        url = "https://crates.io/api/v1/crates/pkg-config/0.3.19/download",
+        type = "tar.gz",
+        sha256 = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c",
+        strip_prefix = "pkg-config-0.3.19",
+        build_file = Label("//sys/complex/raze/remote:BUILD.pkg-config-0.3.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__tinyvec__1_3_1",
+        url = "https://crates.io/api/v1/crates/tinyvec/1.3.1/download",
+        type = "tar.gz",
+        sha256 = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338",
+        strip_prefix = "tinyvec-1.3.1",
+        build_file = Label("//sys/complex/raze/remote:BUILD.tinyvec-1.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__tinyvec_macros__0_1_0",
+        url = "https://crates.io/api/v1/crates/tinyvec_macros/0.1.0/download",
+        type = "tar.gz",
+        sha256 = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c",
+        strip_prefix = "tinyvec_macros-0.1.0",
+        build_file = Label("//sys/complex/raze/remote:BUILD.tinyvec_macros-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__unicode_bidi__0_3_5",
+        url = "https://crates.io/api/v1/crates/unicode-bidi/0.3.5/download",
+        type = "tar.gz",
+        sha256 = "eeb8be209bb1c96b7c177c7420d26e04eccacb0eeae6b980e35fcb74678107e0",
+        strip_prefix = "unicode-bidi-0.3.5",
+        build_file = Label("//sys/complex/raze/remote:BUILD.unicode-bidi-0.3.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__unicode_normalization__0_1_19",
+        url = "https://crates.io/api/v1/crates/unicode-normalization/0.1.19/download",
+        type = "tar.gz",
+        sha256 = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9",
+        strip_prefix = "unicode-normalization-0.1.19",
+        build_file = Label("//sys/complex/raze/remote:BUILD.unicode-normalization-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__url__2_2_2",
+        url = "https://crates.io/api/v1/crates/url/2.2.2/download",
+        type = "tar.gz",
+        sha256 = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c",
+        strip_prefix = "url-2.2.2",
+        build_file = Label("//sys/complex/raze/remote:BUILD.url-2.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "complex_sys__vcpkg__0_2_15",
+        url = "https://crates.io/api/v1/crates/vcpkg/0.2.15/download",
+        type = "tar.gz",
+        sha256 = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426",
+        strip_prefix = "vcpkg-0.2.15",
+        build_file = Label("//sys/complex/raze/remote:BUILD.vcpkg-0.2.15.bazel"),
+    )
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.autocfg-1.0.1.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.autocfg-1.0.1.bazel
new file mode 100644
index 0000000..5faa88d
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.autocfg-1.0.1.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "integers" with type "example" omitted
+
+# Unsupported target "paths" with type "example" omitted
+
+# Unsupported target "traits" with type "example" omitted
+
+# Unsupported target "versions" with type "example" omitted
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "rustflags" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bitflags-1.2.1.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bitflags-1.2.1.bazel
new file mode 100644
index 0000000..09adb27
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.bitflags-1.2.1.bazel
@@ -0,0 +1,85 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "bitflags_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.1",
+    # buildifier: leave-alone
+    deps = [
+        ":bitflags_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cc-1.0.69.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cc-1.0.69.bazel
new file mode 100644
index 0000000..2bc830d
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cc-1.0.69.bazel
@@ -0,0 +1,91 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_gcc_shim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "jobserver",
+        "parallel",
+    ],
+    crate_root = "src/bin/gcc-shim.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    # buildifier: leave-alone
+    deps = [
+        ":cc",
+        "@complex_sys__jobserver__0_1_23//:jobserver",
+    ],
+)
+
+rust_library(
+    name = "cc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "jobserver",
+        "parallel",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__jobserver__0_1_23//:jobserver",
+    ],
+)
+
+# Unsupported target "cc_env" with type "test" omitted
+
+# Unsupported target "cflags" with type "test" omitted
+
+# Unsupported target "cxxflags" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..c2cdc13
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-0.3.2.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-0.3.2.bazel
new file mode 100644
index 0000000..598b30a
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-0.3.2.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "foreign_types",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.2",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__foreign_types_shared__0_1_1//:foreign_types_shared",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-shared-0.1.1.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-shared-0.1.1.bazel
new file mode 100644
index 0000000..b084e4e
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.foreign-types-shared-0.1.1.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "foreign_types_shared",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.form_urlencoded-1.0.1.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.form_urlencoded-1.0.1.bazel
new file mode 100644
index 0000000..4e1962b
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.form_urlencoded-1.0.1.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "form_urlencoded",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.1",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__matches__0_1_8//:matches",
+        "@complex_sys__percent_encoding__2_1_0//:percent_encoding",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.git2-0.13.12.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.git2-0.13.12.bazel
new file mode 100644
index 0000000..2c84c59
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.git2-0.13.12.bazel
@@ -0,0 +1,115 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "add" with type "example" omitted
+
+# Unsupported target "blame" with type "example" omitted
+
+# Unsupported target "cat-file" with type "example" omitted
+
+# Unsupported target "clone" with type "example" omitted
+
+# Unsupported target "diff" with type "example" omitted
+
+# Unsupported target "fetch" with type "example" omitted
+
+# Unsupported target "init" with type "example" omitted
+
+# Unsupported target "log" with type "example" omitted
+
+# Unsupported target "ls-remote" with type "example" omitted
+
+# Unsupported target "pull" with type "example" omitted
+
+# Unsupported target "rev-list" with type "example" omitted
+
+# Unsupported target "rev-parse" with type "example" omitted
+
+# Unsupported target "status" with type "example" omitted
+
+# Unsupported target "tag" with type "example" omitted
+
+rust_library(
+    name = "git2",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "default",
+        "https",
+        "openssl-probe",
+        "openssl-sys",
+        "ssh",
+        "ssh_key_from_memory",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.13.12",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__bitflags__1_2_1//:bitflags",
+        "@complex_sys__libc__0_2_98//:libc",
+        "@complex_sys__libgit2_sys__0_12_21_1_1_0//:libgit2_sys",
+        "@complex_sys__log__0_4_14//:log",
+        "@complex_sys__url__2_2_2//:url",
+    ] + selects.with_or({
+        # cfg(all(unix, not(target_os = "macos")))
+        (
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__openssl_probe__0_1_4//:openssl_probe",
+            "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.idna-0.2.3.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.idna-0.2.3.bazel
new file mode 100644
index 0000000..b558dba
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.idna-0.2.3.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "all" with type "bench" omitted
+
+rust_library(
+    name = "idna",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__matches__0_1_8//:matches",
+        "@complex_sys__unicode_bidi__0_3_5//:unicode_bidi",
+        "@complex_sys__unicode_normalization__0_1_19//:unicode_normalization",
+    ],
+)
+
+# Unsupported target "tests" with type "test" omitted
+
+# Unsupported target "unit" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.jobserver-0.1.23.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.jobserver-0.1.23.bazel
new file mode 100644
index 0000000..bc6f007
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.jobserver-0.1.23.bazel
@@ -0,0 +1,88 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "jobserver",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.23",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__libc__0_2_98//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "client" with type "test" omitted
+
+# Unsupported target "client-of-myself" with type "test" omitted
+
+# Unsupported target "helper" with type "test" omitted
+
+# Unsupported target "make-as-a-client" with type "test" omitted
+
+# Unsupported target "server" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..440c1c9
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libc-0.2.98.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libc-0.2.98.bazel
new file mode 100644
index 0000000..b3a4526
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libc-0.2.98.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libc_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.98",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.98",
+    # buildifier: leave-alone
+    deps = [
+        ":libc_build_script",
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libgit2-sys-0.12.21+1.1.0.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libgit2-sys-0.12.21+1.1.0.bazel
new file mode 100644
index 0000000..63c87f1
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libgit2-sys-0.12.21+1.1.0.bazel
@@ -0,0 +1,149 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libgit2_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "https",
+        "libssh2-sys",
+        "openssl-sys",
+        "ssh",
+        "ssh_key_from_memory",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    links = "git2",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.12.21+1.1.0",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@complex_sys__cc__1_0_69//:cc",
+        "@complex_sys__libssh2_sys__0_2_21//:libssh2_sys",
+        "@complex_sys__libz_sys__1_1_3//:libz_sys",
+        "@complex_sys__pkg_config__0_3_19//:pkg_config",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "libgit2_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "https",
+        "libssh2-sys",
+        "openssl-sys",
+        "ssh",
+        "ssh_key_from_memory",
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.12.21+1.1.0",
+    # buildifier: leave-alone
+    deps = [
+        ":libgit2_sys_build_script",
+        "@complex_sys__libc__0_2_98//:libc",
+        "@complex_sys__libssh2_sys__0_2_21//:libssh2_sys",
+        "@complex_sys__libz_sys__1_1_3//:libz_sys",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libssh2-sys-0.2.21.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libssh2-sys-0.2.21.bazel
new file mode 100644
index 0000000..dab53f1
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libssh2-sys-0.2.21.bazel
@@ -0,0 +1,156 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libssh2_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]) + [
+        "@openssl",
+    ],
+    edition = "2015",
+    links = "ssh2",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.21",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@complex_sys__cc__1_0_69//:cc",
+        "@complex_sys__libz_sys__1_1_3//:libz_sys",
+        "@complex_sys__pkg_config__0_3_19//:pkg_config",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@complex_sys__vcpkg__0_2_15//:vcpkg",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "libssh2_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.21",
+    # buildifier: leave-alone
+    deps = [
+        ":libssh2_sys_build_script",
+        "@complex_sys__libc__0_2_98//:libc",
+        "@complex_sys__libz_sys__1_1_3//:libz_sys",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libz-sys-1.1.3.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libz-sys-1.1.3.bazel
new file mode 100644
index 0000000..88c2b13
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.libz-sys-1.1.3.bazel
@@ -0,0 +1,108 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libz_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "libc",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    links = "z",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.3",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@complex_sys__cc__1_0_69//:cc",
+        "@complex_sys__pkg_config__0_3_19//:pkg_config",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@complex_sys__vcpkg__0_2_15//:vcpkg",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "libz_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "libc",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.3",
+    # buildifier: leave-alone
+    deps = [
+        ":libz_sys_build_script",
+        "@complex_sys__libc__0_2_98//:libc",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.log-0.4.14.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..dbea3b3
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.log-0.4.14.bazel
@@ -0,0 +1,90 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "log_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "value" with type "bench" omitted
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    # buildifier: leave-alone
+    deps = [
+        ":log_build_script",
+        "@complex_sys__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
+
+# Unsupported target "macros" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.matches-0.1.8.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.matches-0.1.8.bazel
new file mode 100644
index 0000000..2b9a32d
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.matches-0.1.8.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "matches",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "macro_use_one" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-0.10.32.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-0.10.32.bazel
new file mode 100644
index 0000000..5dda642
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-0.10.32.bazel
@@ -0,0 +1,92 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "openssl_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.32",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+    ],
+)
+
+# Unsupported target "mk_certs" with type "example" omitted
+
+rust_library(
+    name = "openssl",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.32",
+    # buildifier: leave-alone
+    deps = [
+        ":openssl_build_script",
+        "@complex_sys__bitflags__1_2_1//:bitflags",
+        "@complex_sys__cfg_if__1_0_0//:cfg_if",
+        "@complex_sys__foreign_types__0_3_2//:foreign_types",
+        "@complex_sys__lazy_static__1_4_0//:lazy_static",
+        "@complex_sys__libc__0_2_98//:libc",
+        "@complex_sys__openssl_sys__0_9_60//:openssl_sys",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-probe-0.1.4.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-probe-0.1.4.bazel
new file mode 100644
index 0000000..e8c551b
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-probe-0.1.4.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "openssl_probe",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.4",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-sys-0.9.60.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-sys-0.9.60.bazel
new file mode 100644
index 0000000..c033c83
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.openssl-sys-0.9.60.bazel
@@ -0,0 +1,113 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "openssl_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+        "OPENSSL_DIR": "$(execpath @openssl//:gen_dir)",
+        "OPENSSL_STATIC": "1",
+    },
+    crate_features = [
+    ],
+    crate_root = "build/main.rs",
+    data = glob(["**"]) + [
+        "@openssl//:gen_dir",
+        "@openssl//:openssl",
+    ],
+    edition = "2015",
+    links = "openssl",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.60",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@complex_sys__autocfg__1_0_1//:autocfg",
+        "@complex_sys__cc__1_0_69//:cc",
+        "@complex_sys__pkg_config__0_3_19//:pkg_config",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@complex_sys__vcpkg__0_2_15//:vcpkg",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "openssl_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [] + ["@openssl//:openssl"],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.60",
+    # buildifier: leave-alone
+    deps = [
+        ":openssl_sys_build_script",
+        "@complex_sys__libc__0_2_98//:libc",
+        "@openssl//:openssl",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.percent-encoding-2.1.0.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.percent-encoding-2.1.0.bazel
new file mode 100644
index 0000000..c6db1ca
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.percent-encoding-2.1.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "percent_encoding",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.pkg-config-0.3.19.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.pkg-config-0.3.19.bazel
new file mode 100644
index 0000000..579c9ba
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.pkg-config-0.3.19.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "pkg_config",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.19",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec-1.3.1.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec-1.3.1.bazel
new file mode 100644
index 0000000..ec3dc78
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec-1.3.1.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Zlib from expression "Zlib OR (Apache-2.0 OR MIT)"
+])
+
+# Generated Targets
+
+# Unsupported target "macros" with type "bench" omitted
+
+rust_library(
+    name = "tinyvec",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "default",
+        "tinyvec_macros",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.3.1",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__tinyvec_macros__0_1_0//:tinyvec_macros",
+    ],
+)
+
+# Unsupported target "arrayvec" with type "test" omitted
+
+# Unsupported target "tinyvec" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel
new file mode 100644
index 0000000..898618b
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR (Apache-2.0 OR Zlib)"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tinyvec_macros",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-bidi-0.3.5.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-bidi-0.3.5.bazel
new file mode 100644
index 0000000..eb6eaa4
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-bidi-0.3.5.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "unicode_bidi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.5",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__matches__0_1_8//:matches",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-normalization-0.1.19.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-normalization-0.1.19.bazel
new file mode 100644
index 0000000..eacf38d
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.unicode-normalization-0.1.19.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "unicode_normalization",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.19",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__tinyvec__1_3_1//:tinyvec",
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.url-2.2.2.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.url-2.2.2.bazel
new file mode 100644
index 0000000..37b82d9
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.url-2.2.2.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "parse_url" with type "bench" omitted
+
+rust_library(
+    name = "url",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.2.2",
+    # buildifier: leave-alone
+    deps = [
+        "@complex_sys__form_urlencoded__1_0_1//:form_urlencoded",
+        "@complex_sys__idna__0_2_3//:idna",
+        "@complex_sys__matches__0_1_8//:matches",
+        "@complex_sys__percent_encoding__2_1_0//:percent_encoding",
+    ],
+)
+
+# Unsupported target "data" with type "test" omitted
+
+# Unsupported target "unit" with type "test" omitted
diff --git a/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.vcpkg-0.2.15.bazel b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.vcpkg-0.2.15.bazel
new file mode 100644
index 0000000..6a4c404
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/raze/remote/BUILD.vcpkg-0.2.15.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//sys/complex/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "vcpkg",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.15",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/examples/sys/complex/repositories.bzl b/third_party/rules_rust/examples/sys/complex/repositories.bzl
new file mode 100644
index 0000000..1284191
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/repositories.bzl
@@ -0,0 +1,10 @@
+# buildifier: disable=module-docstring
+load("//sys/complex/raze:crates.bzl", "complex_sys_fetch_remote_crates")
+load("//third_party/openssl:openssl_repositories.bzl", "openssl_repositories")
+
+def complex_sys_repositories():
+    """Define repository dependencies for the `complex_sys` example"""
+
+    complex_sys_fetch_remote_crates()
+
+    openssl_repositories()
diff --git a/third_party/rules_rust/examples/sys/complex/src/main.rs b/third_party/rules_rust/examples/sys/complex/src/main.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/complex/src/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/examples/sys/sys_deps.bzl b/third_party/rules_rust/examples/sys/sys_deps.bzl
new file mode 100644
index 0000000..31716e4
--- /dev/null
+++ b/third_party/rules_rust/examples/sys/sys_deps.bzl
@@ -0,0 +1,14 @@
+# buildifier: disable=module-docstring
+load("//sys/basic/raze:crates.bzl", "basic_sys_fetch_remote_crates")
+load("//sys/complex:repositories.bzl", "complex_sys_repositories")
+
+def sys_deps():
+    """This macro loads dependencies for the `sys` crate examples
+
+    Commonly `*-sys` crates are built on top of some existing library and
+    will have a number of dependencies. The examples here use
+    [cargo-raze](https://github.com/google/cargo-raze) to gather these
+    dependencies and make them avaialble in the workspace.
+    """
+    basic_sys_fetch_remote_crates()
+    complex_sys_repositories()
diff --git a/third_party/rules_rust/examples/third_party/openssl/BUILD.bazel b/third_party/rules_rust/examples/third_party/openssl/BUILD.bazel
new file mode 100644
index 0000000..ea1a6b9
--- /dev/null
+++ b/third_party/rules_rust/examples/third_party/openssl/BUILD.bazel
@@ -0,0 +1,11 @@
+# The code here was picked up from the `rules_foreign_cc` openssl example
+# https://github.com/bazelbuild/rules_foreign_cc/tree/0.5.1/examples/third_party/openssl
+
+exports_files(
+    [
+        "BUILD.nasm.bazel",
+        "BUILD.openssl.bazel",
+        "BUILD.perl.bazel",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/third_party/openssl/BUILD.nasm.bazel b/third_party/rules_rust/examples/third_party/openssl/BUILD.nasm.bazel
new file mode 100644
index 0000000..05d571d
--- /dev/null
+++ b/third_party/rules_rust/examples/third_party/openssl/BUILD.nasm.bazel
@@ -0,0 +1,17 @@
+# The code here was picked up from the `rules_foreign_cc` openssl example
+# https://github.com/bazelbuild/rules_foreign_cc/tree/0.5.1/examples/third_party/openssl
+
+load("@bazel_skylib//rules:select_file.bzl", "select_file")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+select_file(
+    name = "nasm",
+    srcs = ":all_srcs",
+    subpath = "nasm.exe",
+)
diff --git a/third_party/rules_rust/examples/third_party/openssl/BUILD.openssl.bazel b/third_party/rules_rust/examples/third_party/openssl/BUILD.openssl.bazel
new file mode 100644
index 0000000..865fe22
--- /dev/null
+++ b/third_party/rules_rust/examples/third_party/openssl/BUILD.openssl.bazel
@@ -0,0 +1,100 @@
+# The code here was picked up from the `rules_foreign_cc` openssl example
+# https://github.com/bazelbuild/rules_foreign_cc/tree/0.5.1/examples/third_party/openssl
+
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "configure_make", "configure_make_variant")
+
+# Read https://wiki.openssl.org/index.php/Compilation_and_Installation
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+CONFIGURE_OPTIONS = [
+    "no-comp",
+    "no-idea",
+    "no-weak-ssl-ciphers",
+    "no-shared",
+]
+
+LIB_NAME = "openssl"
+
+MAKE_TARGETS = [
+    "build_libs",
+    "install_dev",
+]
+
+config_setting(
+    name = "msvc_compiler",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "msvc-cl",
+    },
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "openssl",
+    actual = select({
+        ":msvc_compiler": "openssl_msvc",
+        "//conditions:default": "openssl_default",
+    }),
+    visibility = ["//visibility:public"],
+)
+
+configure_make_variant(
+    name = "openssl_msvc",
+    build_data = [
+        "@nasm_windows//:nasm",
+        "@perl_windows//:perl",
+    ],
+    configure_command = "Configure",
+    configure_in_place = True,
+    configure_options = CONFIGURE_OPTIONS + [
+        "VC-WIN64A",
+        # Unset Microsoft Assembler (MASM) flags set by built-in MSVC toolchain,
+        # as NASM is unsed to build OpenSSL rather than MASM
+        "ASFLAGS=\" \"",
+    ],
+    configure_prefix = "$PERL",
+    env = {
+        # The Zi flag must be set otherwise OpenSSL fails to build due to missing .pdb files
+        "CFLAGS": "-Zi",
+        "PATH": "$(dirname $(execpath @nasm_windows//:nasm)):$PATH",
+        "PERL": "$(execpath @perl_windows//:perl)",
+    },
+    lib_name = LIB_NAME,
+    lib_source = ":all_srcs",
+    out_static_libs = [
+        "libssl.lib",
+        "libcrypto.lib",
+    ],
+    targets = MAKE_TARGETS,
+    toolchain = "@rules_foreign_cc//toolchains:preinstalled_nmake_toolchain",
+)
+
+configure_make(
+    name = "openssl_default",
+    configure_command = "config",
+    configure_in_place = True,
+    configure_options = CONFIGURE_OPTIONS,
+    env = select({
+        "@platforms//os:macos": {"AR": ""},
+        "//conditions:default": {},
+    }),
+    lib_name = LIB_NAME,
+    lib_source = ":all_srcs",
+    # Note that for Linux builds, libssl must come before libcrypto on the linker command-line.
+    # As such, libssl must be listed before libcrypto
+    out_static_libs = [
+        "libssl.a",
+        "libcrypto.a",
+    ],
+    targets = MAKE_TARGETS,
+)
+
+filegroup(
+    name = "gen_dir",
+    srcs = [":openssl"],
+    output_group = "gen_dir",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/examples/third_party/openssl/BUILD.perl.bazel b/third_party/rules_rust/examples/third_party/openssl/BUILD.perl.bazel
new file mode 100644
index 0000000..9c5d9c1
--- /dev/null
+++ b/third_party/rules_rust/examples/third_party/openssl/BUILD.perl.bazel
@@ -0,0 +1,17 @@
+# The code here was picked up from the `rules_foreign_cc` openssl example
+# https://github.com/bazelbuild/rules_foreign_cc/tree/0.5.1/examples/third_party/openssl
+
+load("@bazel_skylib//rules:select_file.bzl", "select_file")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "all_srcs",
+    srcs = glob(["**"]),
+)
+
+select_file(
+    name = "perl",
+    srcs = ":all_srcs",
+    subpath = "perl/bin/perl.exe",
+)
diff --git a/third_party/rules_rust/examples/third_party/openssl/openssl_repositories.bzl b/third_party/rules_rust/examples/third_party/openssl/openssl_repositories.bzl
new file mode 100644
index 0000000..2047ebf
--- /dev/null
+++ b/third_party/rules_rust/examples/third_party/openssl/openssl_repositories.bzl
@@ -0,0 +1,45 @@
+"""A module defining the third party dependency OpenSSL
+
+The code here was picked up from the `rules_foreign_cc` openssl example
+https://github.com/bazelbuild/rules_foreign_cc/tree/0.5.1/examples/third_party/openssl
+"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+
+def openssl_repositories():
+    maybe(
+        http_archive,
+        name = "openssl",
+        build_file = Label("//third_party/openssl:BUILD.openssl.bazel"),
+        sha256 = "892a0875b9872acd04a9fde79b1f943075d5ea162415de3047c327df33fbaee5",
+        strip_prefix = "openssl-1.1.1k",
+        urls = [
+            "https://mirror.bazel.build/www.openssl.org/source/openssl-1.1.1k.tar.gz",
+            "https://www.openssl.org/source/openssl-1.1.1k.tar.gz",
+            "https://github.com/openssl/openssl/archive/OpenSSL_1_1_1k.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = "nasm_windows",
+        build_file = Label("//third_party/openssl:BUILD.nasm.bazel"),
+        sha256 = "f5c93c146f52b4f1664fa3ce6579f961a910e869ab0dae431bd871bdd2584ef2",
+        strip_prefix = "nasm-2.15.05",
+        urls = [
+            "https://mirror.bazel.build/www.nasm.us/pub/nasm/releasebuilds/2.15.05/win64/nasm-2.15.05-win64.zip",
+            "https://www.nasm.us/pub/nasm/releasebuilds/2.15.05/win64/nasm-2.15.05-win64.zip",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = "perl_windows",
+        build_file = Label("//third_party/openssl:BUILD.perl.bazel"),
+        sha256 = "aeb973da474f14210d3e1a1f942dcf779e2ae7e71e4c535e6c53ebabe632cc98",
+        urls = [
+            "https://mirror.bazel.build/strawberryperl.com/download/5.32.1.1/strawberry-perl-5.32.1.1-64bit.zip",
+            "https://strawberryperl.com/download/5.32.1.1/strawberry-perl-5.32.1.1-64bit.zip",
+        ],
+    )
diff --git a/third_party/rules_rust/examples/version_stamping/BUILD.bazel b/third_party/rules_rust/examples/version_stamping/BUILD.bazel
new file mode 100644
index 0000000..474c80f
--- /dev/null
+++ b/third_party/rules_rust/examples/version_stamping/BUILD.bazel
@@ -0,0 +1,17 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "version_reporter",
+    srcs = ["src/main.rs"],
+    rustc_env_files = [":generate_rustc_env_file"],
+)
+
+# See https://docs.bazel.build/versions/master/user-manual.html#workspace_status for more information.
+genrule(
+    name = "generate_rustc_env_file",
+    outs = ["rustc_env_file"],
+    cmd = "echo \"CARGO_PKG_VERSION=0.1.0-$$(awk '$$1 == \"BUILD_TIMESTAMP\" {print $$2}' bazel-out/volatile-status.txt)\" > $@",
+    stamp = True,
+)
diff --git a/third_party/rules_rust/examples/version_stamping/src/main.rs b/third_party/rules_rust/examples/version_stamping/src/main.rs
new file mode 100644
index 0000000..695c237
--- /dev/null
+++ b/third_party/rules_rust/examples/version_stamping/src/main.rs
@@ -0,0 +1,17 @@
+// Copyright 2021 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+fn main() {
+    println!("Version: {}", env!("CARGO_PKG_VERSION"));
+}
diff --git a/third_party/rules_rust/examples/wasm/BUILD.bazel b/third_party/rules_rust/examples/wasm/BUILD.bazel
new file mode 100644
index 0000000..e499c31
--- /dev/null
+++ b/third_party/rules_rust/examples/wasm/BUILD.bazel
@@ -0,0 +1,79 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("@build_bazel_rules_nodejs//:index.bzl", "nodejs_test")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_shared_library")
+load("@rules_rust//wasm_bindgen:wasm_bindgen.bzl", "rust_wasm_bindgen")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "hello_world_bin_wasm",
+    srcs = ["main.rs"],
+    edition = "2018",
+    deps = [
+        "@rules_rust//wasm_bindgen/raze:wasm_bindgen",
+    ],
+)
+
+rust_shared_library(
+    name = "hello_world_lib_wasm",
+    srcs = ["main.rs"],
+    edition = "2018",
+    deps = [
+        "@rules_rust//wasm_bindgen/raze:wasm_bindgen",
+    ],
+)
+
+rust_wasm_bindgen(
+    name = "hello_world_bundler_wasm_bindgen",
+    wasm_file = ":hello_world_bin_wasm",
+)
+
+rust_wasm_bindgen(
+    name = "hello_world_web_wasm_bindgen",
+    target = "web",
+    wasm_file = ":hello_world_lib_wasm",
+)
+
+rust_wasm_bindgen(
+    name = "hello_world_deno_wasm_bindgen",
+    target = "deno",
+    wasm_file = ":hello_world_lib_wasm",
+)
+
+rust_wasm_bindgen(
+    name = "hello_world_nomodules_wasm_bindgen",
+    target = "no-modules",
+    wasm_file = ":hello_world_lib_wasm",
+)
+
+rust_wasm_bindgen(
+    name = "hello_world_nodejs_wasm_bindgen",
+    target = "nodejs",
+    wasm_file = ":hello_world_lib_wasm",
+)
+
+nodejs_test(
+    name = "hello_world_wasm_test",
+    data = [
+        ":hello_world_bundler_wasm_bindgen",
+        ":hello_world_deno_wasm_bindgen",
+        ":hello_world_nodejs_wasm_bindgen",
+        ":hello_world_nomodules_wasm_bindgen",
+        ":hello_world_web_wasm_bindgen",
+    ],
+    entry_point = "hello_world_wasm_test.js",
+)
diff --git a/third_party/rules_rust/examples/wasm/hello_world_wasm_test.js b/third_party/rules_rust/examples/wasm/hello_world_wasm_test.js
new file mode 100644
index 0000000..8712335
--- /dev/null
+++ b/third_party/rules_rust/examples/wasm/hello_world_wasm_test.js
@@ -0,0 +1,23 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+const main = async function (typ) {
+  const wasm_file = path.join(__dirname, 'hello_world_'+typ+'_wasm_bindgen_bg.wasm');
+  assert.ok(fs.existsSync(wasm_file));
+
+  const buf = fs.readFileSync(wasm_file);
+  assert.ok(buf);
+
+  const res = await WebAssembly.instantiate(buf);
+  assert.ok(res);
+  assert.strictEqual(res.instance.exports.double(2), 4);
+};
+
+["bundler", "web", "deno", "nomodules", "nodejs"].forEach((typ) => {
+  main(typ).catch(function (err) {
+    console.error(err);
+    process.exit(1);
+  });
+})
diff --git a/third_party/rules_rust/examples/wasm/main.rs b/third_party/rules_rust/examples/wasm/main.rs
new file mode 100644
index 0000000..8703ad3
--- /dev/null
+++ b/third_party/rules_rust/examples/wasm/main.rs
@@ -0,0 +1,11 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn double(i: i32) -> i32 {
+    i * 2
+}
+
+#[allow(dead_code)]
+fn main() {
+    println!("Hello {}", double(2));
+}
diff --git a/third_party/rules_rust/proto/BUILD.bazel b/third_party/rules_rust/proto/BUILD.bazel
new file mode 100644
index 0000000..1b7fa26
--- /dev/null
+++ b/third_party/rules_rust/proto/BUILD.bazel
@@ -0,0 +1,42 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//rust:defs.bzl", "rust_binary")
+load(":toolchain.bzl", "rust_proto_toolchain")
+
+package(default_visibility = ["//visibility:public"])
+
+alias(
+    name = "protoc_gen_rust",
+    actual = "//proto/raze:cargo_bin_protoc_gen_rust",
+)
+
+alias(
+    name = "protoc_gen_rust_grpc",
+    actual = "//proto/raze:cargo_bin_protoc_gen_rust_grpc",
+)
+
+toolchain_type(name = "toolchain")
+
+rust_binary(
+    name = "optional_output_wrapper",
+    srcs = ["optional_output_wrapper.rs"],
+    visibility = ["//visibility:public"],
+)
+
+toolchain(
+    name = "default-proto-toolchain",
+    toolchain = ":default-proto-toolchain-impl",
+    toolchain_type = "@rules_rust//proto:toolchain",
+)
+
+rust_proto_toolchain(name = "default-proto-toolchain-impl")
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]) + ["//proto/raze:crates.bzl"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//proto:bzl_lib` target instead",
+)
diff --git a/third_party/rules_rust/proto/README.md b/third_party/rules_rust/proto/README.md
new file mode 100644
index 0000000..9f470c7
--- /dev/null
+++ b/third_party/rules_rust/proto/README.md
@@ -0,0 +1,9 @@
+# Rust Protobuf Rules
+
+These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel.
+
+[rust]: http://www.rust-lang.org/
+[protobuf]: https://developers.google.com/protocol-buffers/
+[grpc]: https://grpc.io
+
+More information can be found in the [rules_rust documentation](https://bazelbuild.github.io/rules_rust/rust_proto.html).
diff --git a/third_party/rules_rust/proto/optional_output_wrapper.rs b/third_party/rules_rust/proto/optional_output_wrapper.rs
new file mode 100644
index 0000000..59eba1b
--- /dev/null
+++ b/third_party/rules_rust/proto/optional_output_wrapper.rs
@@ -0,0 +1,57 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+use std::env::args;
+use std::error;
+use std::fs::File;
+use std::path::Path;
+use std::process::Command;
+
+// A simple wrapper around a binary to ensure we always create some outputs
+// Optional outputs are not available in Skylark :(
+// Syntax: $0 output1 output2 ... -- program  [arg1...argn]
+fn ensure() -> Result<i32, Box<dyn error::Error>> {
+    let index = args().position(|a| a == "--").ok_or("no --")?;
+    let optional_outputs = args().take(index).collect::<Vec<String>>();
+    let exe = args().nth(index + 1).ok_or("no exe")?;
+    let exe_args = args().skip(index + 2).collect::<Vec<String>>();
+    if exe_args.is_empty() {
+        return Err("no exe args".into());
+    }
+    match Command::new(exe).args(exe_args).status()?.code() {
+        Some(code) => {
+            if code == 0 {
+                for out in optional_outputs {
+                    if !Path::new(&out).exists() {
+                        let _ = File::create(out)?;
+                    }
+                }
+            }
+            Ok(code)
+        }
+        None => Err("process killed".into()),
+    }
+}
+
+fn main() {
+    std::process::exit(match ensure() {
+        Ok(exit_code) => exit_code,
+        Err(e) => {
+            println!("Usage: [optional_output1...optional_outputN] -- program [arg1...argn]");
+            println!("{:?}", args());
+            println!("{:?}", e);
+            -1
+        }
+    });
+}
diff --git a/third_party/rules_rust/proto/patches/BUILD.bazel b/third_party/rules_rust/proto/patches/BUILD.bazel
new file mode 100644
index 0000000..fb662c8
--- /dev/null
+++ b/third_party/rules_rust/proto/patches/BUILD.bazel
@@ -0,0 +1,5 @@
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "com_google_protobuf-v3.10.0-bzl_visibility.patch",
+])
diff --git a/third_party/rules_rust/proto/patches/README.md b/third_party/rules_rust/proto/patches/README.md
new file mode 100644
index 0000000..7d4ca11
--- /dev/null
+++ b/third_party/rules_rust/proto/patches/README.md
@@ -0,0 +1,3 @@
+# @rules_rust//proto patches
+
+The patches here provide the required visibility to `*.bzl` files used by the rules defined in `com_google_protobuf`.
diff --git a/third_party/rules_rust/proto/patches/com_google_protobuf-v3.10.0-bzl_visibility.patch b/third_party/rules_rust/proto/patches/com_google_protobuf-v3.10.0-bzl_visibility.patch
new file mode 100644
index 0000000..ad694e2
--- /dev/null
+++ b/third_party/rules_rust/proto/patches/com_google_protobuf-v3.10.0-bzl_visibility.patch
@@ -0,0 +1,14 @@
+diff --git a/BUILD b/BUILD
+index efc3d8e7f..77e3ea413 100644
+--- a/BUILD
++++ b/BUILD
+@@ -1236,3 +1236,9 @@ sh_test(
+         "update_file_lists.sh",
+     ],
+ )
++
++filegroup(
++    name = "bzl_srcs",
++    srcs = glob(["**/*.bzl"]),
++    visibility = ["//visibility:public"],
++)
diff --git a/third_party/rules_rust/proto/proto.bzl b/third_party/rules_rust/proto/proto.bzl
new file mode 100644
index 0000000..ea239b0
--- /dev/null
+++ b/third_party/rules_rust/proto/proto.bzl
@@ -0,0 +1,432 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Rust Protobuf Rules
+
+These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel.
+
+[rust]: http://www.rust-lang.org/
+[protobuf]: https://developers.google.com/protocol-buffers/
+[grpc]: https://grpc.io
+
+### Setup
+
+To use the Rust proto rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust proto toolchain (in addition to the [rust rules setup](..)):
+
+```python
+load("//proto:repositories.bzl", "rust_proto_repositories")
+
+rust_proto_repositories()
+```
+"""
+
+load("@rules_proto//proto:defs.bzl", "ProtoInfo")
+load(
+    "//proto:toolchain.bzl",
+    _generate_proto = "rust_generate_proto",
+    _generated_file_stem = "generated_file_stem",
+)
+load("//rust:defs.bzl", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:rustc.bzl", "rustc_compile_action")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "compute_crate_name", "determine_output_hash", "find_toolchain", "transform_deps")
+
+RustProtoInfo = provider(
+    doc = "Rust protobuf provider info",
+    fields = {
+        "proto_sources": "List[string]: list of source paths of protos",
+        "transitive_proto_sources": "depset[string]",
+    },
+)
+
+def _compute_proto_source_path(file, source_root_attr):
+    """Take the short path of file and make it suitable for protoc.
+
+    Args:
+        file (File): The target source file.
+        source_root_attr (str): The directory relative to which the `.proto` \
+            files defined in the proto_library are defined.
+
+    Returns:
+        str: The protoc suitible path of `file`
+    """
+
+    # Bazel creates symlinks to the .proto files under a directory called
+    # "_virtual_imports/<rule name>" if we do any sort of munging of import
+    # paths (e.g. using strip_import_prefix / import_prefix attributes)
+    virtual_imports = "/_virtual_imports/"
+    if virtual_imports in file.path:
+        return file.path.split(virtual_imports)[1].split("/", 1)[1]
+
+    # For proto, they need to be requested with their absolute name to be
+    # compatible with the descriptor_set passed by proto_library.
+    # I.e. if you compile a protobuf at @repo1//package:file.proto, the proto
+    # compiler would generate a file descriptor with the path
+    # `package/file.proto`. Since we compile from the proto descriptor, we need
+    # to pass the list of descriptors and the list of path to compile.
+    # For the precedent example, the file (noted `f`) would have
+    # `f.short_path` returns `external/repo1/package/file.proto`.
+    # In addition, proto_library can provide a proto_source_path to change the base
+    # path, which should a be a prefix.
+    path = file.short_path
+
+    # Strip external prefix.
+    path = path.split("/", 2)[2] if path.startswith("../") else path
+
+    # Strip source_root.
+    if path.startswith(source_root_attr):
+        return path[len(source_root_attr):]
+    else:
+        return path
+
+def _rust_proto_aspect_impl(target, ctx):
+    """The implementation of the `rust_proto_aspect` aspect
+
+    Args:
+        target (Target): The target to which the aspect is applied
+        ctx (ctx): The rule context which the targetis created from
+
+    Returns:
+        list: A list containg a `RustProtoInfo` provider
+    """
+    if ProtoInfo not in target:
+        return None
+
+    if hasattr(ctx.rule.attr, "proto_source_root"):
+        source_root = ctx.rule.attr.proto_source_root
+    else:
+        source_root = ""
+
+    if source_root and source_root[-1] != "/":
+        source_root += "/"
+
+    sources = [
+        _compute_proto_source_path(f, source_root)
+        for f in target[ProtoInfo].direct_sources
+    ]
+    transitive_sources = [
+        f[RustProtoInfo].transitive_proto_sources
+        for f in ctx.rule.attr.deps
+        if RustProtoInfo in f
+    ]
+    return [RustProtoInfo(
+        proto_sources = sources,
+        transitive_proto_sources = depset(transitive = transitive_sources, direct = sources),
+    )]
+
+_rust_proto_aspect = aspect(
+    doc = "An aspect that gathers rust proto direct and transitive sources",
+    implementation = _rust_proto_aspect_impl,
+    attr_aspects = ["deps"],
+)
+
+def _gen_lib(ctx, grpc, srcs, lib):
+    """Generate a lib.rs file for the crates.
+
+    Args:
+        ctx (ctx): The current rule's context object
+        grpc (bool): True if the current rule is a `gRPC` rule.
+        srcs (list): A list of protoc suitible file paths (str).
+        lib (File): The File object where the rust source file should be written
+    """
+    content = ["extern crate protobuf;"]
+    if grpc:
+        content.append("extern crate grpc;")
+        content.append("extern crate tls_api;")
+    for f in srcs.to_list():
+        content.append("pub mod %s;" % _generated_file_stem(f))
+        content.append("pub use %s::*;" % _generated_file_stem(f))
+        if grpc:
+            content.append("pub mod %s_grpc;" % _generated_file_stem(f))
+            content.append("pub use %s_grpc::*;" % _generated_file_stem(f))
+    ctx.actions.write(lib, "\n".join(content))
+
+def _expand_provider(lst, provider):
+    """Gathers a list of a specific provider from a list of targets.
+
+    Args:
+        lst (list): A list of Targets
+        provider (Provider): The target provider type to extract `lst`
+
+    Returns:
+        list: A list of providers of the type from `provider`.
+    """
+    return [el[provider] for el in lst if provider in el]
+
+def _rust_proto_compile(protos, descriptor_sets, imports, crate_name, ctx, is_grpc, compile_deps, toolchain):
+    """Create and run a rustc compile action based on the current rule's attributes
+
+    Args:
+        protos (depset): Paths of protos to compile.
+        descriptor_sets (depset): A set of transitive protobuf `FileDescriptorSet`s
+        imports (depset): A set of transitive protobuf Imports.
+        crate_name (str): The name of the Crate for the current target
+        ctx (ctx): The current rule's context object
+        is_grpc (bool): True if the current rule is a `gRPC` rule.
+        compile_deps (list): A list of Rust dependencies (`List[Target]`)
+        toolchain (rust_toolchain): the current `rust_toolchain`.
+
+    Returns:
+        list: A list of providers, see `rustc_compile_action`
+    """
+
+    # Create all the source in a specific folder
+    proto_toolchain = ctx.toolchains[Label("//proto:toolchain")]
+    output_dir = "%s.%s.rust" % (crate_name, "grpc" if is_grpc else "proto")
+
+    # Generate the proto stubs
+    srcs = _generate_proto(
+        ctx,
+        descriptor_sets,
+        protos = protos,
+        imports = imports,
+        output_dir = output_dir,
+        proto_toolchain = proto_toolchain,
+        is_grpc = is_grpc,
+    )
+
+    # and lib.rs
+    lib_rs = ctx.actions.declare_file("%s/lib.rs" % output_dir)
+    _gen_lib(ctx, is_grpc, protos, lib_rs)
+    srcs.append(lib_rs)
+
+    # And simulate rust_library behavior
+    output_hash = determine_output_hash(lib_rs, ctx.label)
+    rust_lib = ctx.actions.declare_file("%s/lib%s-%s.rlib" % (
+        output_dir,
+        crate_name,
+        output_hash,
+    ))
+
+    # Gather all dependencies for compilation
+    compile_action_deps = depset(
+        transform_deps(
+            compile_deps +
+            proto_toolchain.grpc_compile_deps if is_grpc else proto_toolchain.proto_compile_deps,
+        ),
+    )
+
+    return rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = "rlib",
+            root = lib_rs,
+            srcs = depset(srcs),
+            deps = compile_action_deps,
+            proc_macro_deps = depset([]),
+            aliases = {},
+            output = rust_lib,
+            edition = proto_toolchain.edition,
+            rustc_env = {},
+            is_test = False,
+            compile_data = depset([target.files for target in getattr(ctx.attr, "compile_data", [])]),
+            wrapped_crate_type = None,
+            owner = ctx.label,
+        ),
+        output_hash = output_hash,
+    )
+
+def _rust_protogrpc_library_impl(ctx, is_grpc):
+    """Implementation of the rust_(proto|grpc)_library.
+
+    Args:
+        ctx (ctx): The current rule's context object
+        is_grpc (bool): True if the current rule is a `gRPC` rule.
+
+    Returns:
+        list: A list of providers, see `_rust_proto_compile`
+    """
+    proto = _expand_provider(ctx.attr.deps, ProtoInfo)
+    transitive_sources = [
+        f[RustProtoInfo].transitive_proto_sources
+        for f in ctx.attr.deps
+        if RustProtoInfo in f
+    ]
+
+    toolchain = find_toolchain(ctx)
+    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain)
+
+    return _rust_proto_compile(
+        protos = depset(transitive = transitive_sources),
+        descriptor_sets = depset(transitive = [p.transitive_descriptor_sets for p in proto]),
+        imports = depset(transitive = [p.transitive_imports for p in proto]),
+        crate_name = crate_name,
+        ctx = ctx,
+        is_grpc = is_grpc,
+        compile_deps = ctx.attr.rust_deps,
+        toolchain = toolchain,
+    )
+
+def _rust_proto_library_impl(ctx):
+    """The implementation of the `rust_proto_library` rule
+
+    Args:
+        ctx (ctx): The rule's context object.
+
+    Returns:
+        list: A list of providers, see `_rust_protogrpc_library_impl`
+    """
+    return _rust_protogrpc_library_impl(ctx, False)
+
+rust_proto_library = rule(
+    implementation = _rust_proto_library_impl,
+    attrs = {
+        "deps": attr.label_list(
+            doc = (
+                "List of proto_library dependencies that will be built. " +
+                "One crate for each proto_library will be created with the corresponding stubs."
+            ),
+            mandatory = True,
+            providers = [ProtoInfo],
+            aspects = [_rust_proto_aspect],
+        ),
+        "rust_deps": attr.label_list(
+            doc = "The crates the generated library depends on.",
+        ),
+        "_cc_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+        "_optional_output_wrapper": attr.label(
+            executable = True,
+            cfg = "exec",
+            default = Label("//proto:optional_output_wrapper"),
+        ),
+        "_process_wrapper": attr.label(
+            default = Label("//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+    },
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//proto:toolchain")),
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    # TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use
+    # the version of Bazel that issue was closed on as the min supported version
+    incompatible_use_toolchain_transition = True,
+    doc = """\
+Builds a Rust library crate from a set of `proto_library`s.
+
+Example:
+
+```python
+load("@rules_rust//proto:proto.bzl", "rust_proto_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_proto_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_proto_binary",
+    srcs = ["my_proto_binary.rs"],
+    deps = [":rust"],
+)
+```
+""",
+)
+
+def _rust_grpc_library_impl(ctx):
+    """The implementation of the `rust_grpc_library` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers. See `_rust_protogrpc_library_impl`
+    """
+    return _rust_protogrpc_library_impl(ctx, True)
+
+rust_grpc_library = rule(
+    implementation = _rust_grpc_library_impl,
+    attrs = {
+        "deps": attr.label_list(
+            doc = (
+                "List of proto_library dependencies that will be built. " +
+                "One crate for each proto_library will be created with the corresponding gRPC stubs."
+            ),
+            mandatory = True,
+            providers = [ProtoInfo],
+            aspects = [_rust_proto_aspect],
+        ),
+        "rust_deps": attr.label_list(
+            doc = "The crates the generated library depends on.",
+        ),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_optional_output_wrapper": attr.label(
+            executable = True,
+            cfg = "exec",
+            default = Label("//proto:optional_output_wrapper"),
+        ),
+        "_process_wrapper": attr.label(
+            default = Label("//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+    },
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//proto:toolchain")),
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    # TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use
+    # the version of Bazel that issue was closed on as the min supported version
+    incompatible_use_toolchain_transition = True,
+    doc = """\
+Builds a Rust library crate from a set of `proto_library`s suitable for gRPC.
+
+Example:
+
+```python
+load("//proto:proto.bzl", "rust_grpc_library")
+
+proto_library(
+    name = "my_proto",
+    srcs = ["my.proto"]
+)
+
+rust_grpc_library(
+    name = "rust",
+    deps = [":my_proto"],
+)
+
+rust_binary(
+    name = "my_service",
+    srcs = ["my_service.rs"],
+    deps = [":rust"],
+)
+```
+""",
+)
diff --git a/third_party/rules_rust/proto/raze/BUILD.bazel b/third_party/rules_rust/proto/raze/BUILD.bazel
new file mode 100644
index 0000000..d23e6cb
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/BUILD.bazel
@@ -0,0 +1,102 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "grpc",
+    actual = "@rules_rust_proto__grpc__0_6_2//:grpc",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "cargo_bin_protoc_gen_rust_grpc",
+    actual = "@rules_rust_proto__grpc_compiler__0_6_2//:cargo_bin_protoc_gen_rust_grpc",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "grpc_compiler",
+    actual = "@rules_rust_proto__grpc_compiler__0_6_2//:grpc_compiler",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "log",
+    actual = "@rules_rust_proto__log__0_4_6//:log",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "protobuf",
+    actual = "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "cargo_bin_protoc_gen_rust",
+    actual = "@rules_rust_proto__protobuf_codegen__2_8_2//:cargo_bin_protoc_gen_rust",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "protobuf_codegen",
+    actual = "@rules_rust_proto__protobuf_codegen__2_8_2//:protobuf_codegen",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "tls_api",
+    actual = "@rules_rust_proto__tls_api__0_1_22//:tls_api",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "tls_api_stub",
+    actual = "@rules_rust_proto__tls_api_stub__0_1_22//:tls_api_stub",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/proto/raze/Cargo.lock b/third_party/rules_rust/proto/raze/Cargo.lock
new file mode 100644
index 0000000..2c6b3d0
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/Cargo.lock
@@ -0,0 +1,782 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "autocfg"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "base64"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "safemem 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "byteorder"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "bytes"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memoffset 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fake_lib"
+version = "0.0.1"
+dependencies = [
+ "grpc 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "grpc-compiler 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "protobuf 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "protobuf-codegen 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api-stub 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "futures"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "futures-cpupool"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "grpc"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "httpbis 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "protobuf 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api-stub 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "grpc-compiler"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "protobuf 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "protobuf-codegen 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "httpbis"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api-stub 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-timer 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unix_socket 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "libc"
+version = "0.2.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "lock_api"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "log"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "memoffset"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "mio"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "mio-uds"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "hermit-abi 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lock_api 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot_core 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "protobuf"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "protobuf-codegen"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "protobuf 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "safemem"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "scoped-tls"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "slab"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "slab"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "smallvec"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tls-api"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tls-api-stub"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-codec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-current-thread 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-fs 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-sync 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-tcp 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-threadpool 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-timer 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-udp 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-uds 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-codec"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-core"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "scoped-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-timer 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-current-thread"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-executor"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-fs"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-threadpool 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-io"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-reactor"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-sync 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-sync"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-tcp"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-threadpool"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-timer"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-timer"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-tls-api"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-udp"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-codec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-uds"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tokio-uds"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-codec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unix_socket"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[metadata]
+"checksum autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
+"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
+"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+"checksum crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285"
+"checksum crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
+"checksum crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db"
+"checksum crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
+"checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
+"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+"checksum futures 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)" = "1b980f2816d6ee8673b6517b52cb0e808a180efc92e5c19d02cdda79066703ef"
+"checksum futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4"
+"checksum grpc 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "2aaf1d741fe6f3413f1f9f71b99f5e4e26776d563475a8a53ce53a73a8534c1d"
+"checksum grpc-compiler 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "907274ce8ee7b40a0d0b0db09022ea22846a47cfb1fc8ad2c983c70001b4ffb1"
+"checksum hermit-abi 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8a0d737e0f947a1864e93d33fdef4af8445a00d1ed8dc0c8ddb73139ea6abf15"
+"checksum httpbis 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7689cfa896b2a71da4f16206af167542b75d242b6906313e53857972a92d5614"
+"checksum iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+"checksum libc 0.2.69 (registry+https://github.com/rust-lang/crates.io-index)" = "99e85c08494b21a9054e7fe1374a732aeadaff3980b6990b94bfd3a70f690005"
+"checksum lock_api 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
+"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+"checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6"
+"checksum maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+"checksum memoffset 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b4fc2c02a7e374099d4ee95a193111f72d2110197fe200272371758f6c3643d8"
+"checksum mio 0.6.21 (registry+https://github.com/rust-lang/crates.io-index)" = "302dec22bcf6bae6dfb69c647187f4b4d0fb6f535521f7bc022430ce8e12008f"
+"checksum mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "966257a94e196b11bb43aca423754d87429960a768de9414f3691d6957abf125"
+"checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
+"checksum net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88"
+"checksum num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+"checksum parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252"
+"checksum parking_lot_core 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b876b1b9e7ac6e1a74a6da34d25c42e17e8862aa409cbbbdcfc8d86c6f3bc62b"
+"checksum protobuf 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "70731852eec72c56d11226c8a5f96ad5058a3dab73647ca5f7ee351e464f2571"
+"checksum protobuf-codegen 2.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "3d74b9cbbf2ac9a7169c85a3714ec16c51ee9ec7cfd511549527e9a7df720795"
+"checksum redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)" = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+"checksum safemem 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
+"checksum scoped-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "332ffa32bf586782a3efaeb58f127980944bbc8c4d6913a86107ac2a5ab24b28"
+"checksum scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+"checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+"checksum slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17b4fcaed89ab08ef143da37bc52adbcc04d4a69014f4c1208d6b51f0c47bc23"
+"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
+"checksum smallvec 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "f7b0758c52e15a8b5e3691eae6cc559f08eee9406e548a4477ba4e67770a82b6"
+"checksum tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "049c03787a0595182357fbd487577947f4351b78ce20c3668f6d49f17feb13d1"
+"checksum tls-api-stub 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "c9a0cc8c149724db9de7d73a0e1bc80b1a74f5394f08c6f301e11f9c35fa061e"
+"checksum tokio 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6"
+"checksum tokio-codec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b"
+"checksum tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "aeeffbbb94209023feaef3c196a41cbcdafa06b4a6f893f68779bb5e53796f71"
+"checksum tokio-current-thread 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b1de0e32a83f131e002238d7ccde18211c0a5397f60cbfffcb112868c2e0e20e"
+"checksum tokio-executor 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "fb2d1b8f4548dbf5e1f7818512e9c406860678f29c300cdf0ebac72d1a3a1671"
+"checksum tokio-fs 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4"
+"checksum tokio-io 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674"
+"checksum tokio-reactor 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "09bc590ec4ba8ba87652da2068d150dcada2cfa2e07faae270a5e0409aa51351"
+"checksum tokio-sync 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "edfe50152bc8164fcc456dab7891fa9bf8beaf01c5ee7e1dd43a397c3cf87dee"
+"checksum tokio-tcp 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "98df18ed66e3b72e742f185882a9e201892407957e45fbff8da17ae7a7c51f72"
+"checksum tokio-threadpool 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "df720b6581784c118f0eb4310796b12b1d242a7eb95f716a8367855325c25f89"
+"checksum tokio-timer 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6131e780037787ff1b3f8aad9da83bca02438b72277850dd6ad0d455e0e20efc"
+"checksum tokio-timer 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "93044f2d313c95ff1cb7809ce9a7a05735b012288a888b62d4434fd58c94f296"
+"checksum tokio-tls-api 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "68d0e040d5b1f4cfca70ec4f371229886a5de5bb554d272a4a8da73004a7b2c9"
+"checksum tokio-udp 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82"
+"checksum tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "65ae5d255ce739e8537221ed2942e0445f4b3b813daebac1c0050ddaaa3587f9"
+"checksum tokio-uds 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5076db410d6fdc6523df7595447629099a1fdc47b3d9f896220780fa48faf798"
+"checksum unix_socket 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6aa2700417c405c38f5e6902d699345241c28c0b7ade4abaad71e35a87eb1564"
+"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+"checksum winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+"checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
diff --git a/third_party/rules_rust/proto/raze/Cargo.toml b/third_party/rules_rust/proto/raze/Cargo.toml
new file mode 100644
index 0000000..773554d
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/Cargo.toml
@@ -0,0 +1,47 @@
+
+[package]
+name = "fake_rules_rust_proto"
+version = "0.0.1"
+
+[lib]
+path = "fake_rules_rust_proto.rs"
+
+[dependencies]
+# Newer version of protobuf have been released, but the 0.6.2 release of
+# grpc-rust doesn't work with 2.10 or above, and the 2.9 release pulled.
+protobuf = { version = "2.8.2", features = ["with-bytes"] }
+protobuf-codegen = "2.8.2"
+grpc = "0.6.2"
+grpc-compiler = "0.6.2"
+# Newer version of tls-api have been released, but the 0.1 release is still
+# required by grpc 0.6.2, so continue to use 0.1 of tls-api here.
+tls-api = "0.1.22"
+tls-api-stub = "0.1.22"
+# This needs to be specified, as log 0.3 depends on log 0.4, and log 0.4.7 and
+# up break log 0.3, which is needed by tokio-uds-0.1.7 (which is required by
+# httpbis 0.7.0, which hasn't had a version released in a while).  grpc
+# requires httpbis.
+log = "0.4, <0.4.7"
+
+[package.metadata.raze]
+genmode = "Remote"
+workspace_path = "//proto/raze"
+gen_workspace_prefix = "rules_rust_proto"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "."
+default_gen_buildrs = false
+
+[package.metadata.raze.crates.lazy_static.'1.4.0']
+additional_flags = [
+  "--cfg=lazy_static_heap_impl",
+]
+
+[package.metadata.raze.crates.protobuf.'2.8.2']
+patches = ["@rules_rust//proto/raze/patch:protobuf-2.8.2.patch"]
+patch_args = ["-p1"]
+
+[package.metadata.raze.crates.protobuf-codegen.'2.8.2']
+extra_aliased_targets = ["cargo_bin_protoc_gen_rust"]
+
+[package.metadata.raze.crates.grpc-compiler.'0.6.2']
+extra_aliased_targets = ["cargo_bin_protoc_gen_rust_grpc"]
diff --git a/third_party/rules_rust/proto/raze/crates.bzl b/third_party/rules_rust/proto/raze/crates.bzl
new file mode 100644
index 0000000..3ec2de1
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/crates.bzl
@@ -0,0 +1,768 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def rules_rust_proto_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__autocfg__1_0_0",
+        url = "https://crates.io/api/v1/crates/autocfg/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d",
+        strip_prefix = "autocfg-1.0.0",
+        build_file = Label("//proto/raze/remote:BUILD.autocfg-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__base64__0_9_3",
+        url = "https://crates.io/api/v1/crates/base64/0.9.3/download",
+        type = "tar.gz",
+        sha256 = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643",
+        strip_prefix = "base64-0.9.3",
+        build_file = Label("//proto/raze/remote:BUILD.base64-0.9.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__bitflags__1_2_1",
+        url = "https://crates.io/api/v1/crates/bitflags/1.2.1/download",
+        type = "tar.gz",
+        sha256 = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693",
+        strip_prefix = "bitflags-1.2.1",
+        build_file = Label("//proto/raze/remote:BUILD.bitflags-1.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__byteorder__1_3_4",
+        url = "https://crates.io/api/v1/crates/byteorder/1.3.4/download",
+        type = "tar.gz",
+        sha256 = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de",
+        strip_prefix = "byteorder-1.3.4",
+        build_file = Label("//proto/raze/remote:BUILD.byteorder-1.3.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__bytes__0_4_12",
+        url = "https://crates.io/api/v1/crates/bytes/0.4.12/download",
+        type = "tar.gz",
+        sha256 = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c",
+        strip_prefix = "bytes-0.4.12",
+        build_file = Label("//proto/raze/remote:BUILD.bytes-0.4.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__cfg_if__0_1_10",
+        url = "https://crates.io/api/v1/crates/cfg-if/0.1.10/download",
+        type = "tar.gz",
+        sha256 = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822",
+        strip_prefix = "cfg-if-0.1.10",
+        build_file = Label("//proto/raze/remote:BUILD.cfg-if-0.1.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__cloudabi__0_0_3",
+        url = "https://crates.io/api/v1/crates/cloudabi/0.0.3/download",
+        type = "tar.gz",
+        sha256 = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f",
+        strip_prefix = "cloudabi-0.0.3",
+        build_file = Label("//proto/raze/remote:BUILD.cloudabi-0.0.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__crossbeam_deque__0_7_3",
+        url = "https://crates.io/api/v1/crates/crossbeam-deque/0.7.3/download",
+        type = "tar.gz",
+        sha256 = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285",
+        strip_prefix = "crossbeam-deque-0.7.3",
+        build_file = Label("//proto/raze/remote:BUILD.crossbeam-deque-0.7.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__crossbeam_epoch__0_8_2",
+        url = "https://crates.io/api/v1/crates/crossbeam-epoch/0.8.2/download",
+        type = "tar.gz",
+        sha256 = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace",
+        strip_prefix = "crossbeam-epoch-0.8.2",
+        build_file = Label("//proto/raze/remote:BUILD.crossbeam-epoch-0.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__crossbeam_queue__0_2_1",
+        url = "https://crates.io/api/v1/crates/crossbeam-queue/0.2.1/download",
+        type = "tar.gz",
+        sha256 = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db",
+        strip_prefix = "crossbeam-queue-0.2.1",
+        build_file = Label("//proto/raze/remote:BUILD.crossbeam-queue-0.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__crossbeam_utils__0_7_2",
+        url = "https://crates.io/api/v1/crates/crossbeam-utils/0.7.2/download",
+        type = "tar.gz",
+        sha256 = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8",
+        strip_prefix = "crossbeam-utils-0.7.2",
+        build_file = Label("//proto/raze/remote:BUILD.crossbeam-utils-0.7.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__fnv__1_0_6",
+        url = "https://crates.io/api/v1/crates/fnv/1.0.6/download",
+        type = "tar.gz",
+        sha256 = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3",
+        strip_prefix = "fnv-1.0.6",
+        build_file = Label("//proto/raze/remote:BUILD.fnv-1.0.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__fuchsia_zircon__0_3_3",
+        url = "https://crates.io/api/v1/crates/fuchsia-zircon/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82",
+        strip_prefix = "fuchsia-zircon-0.3.3",
+        build_file = Label("//proto/raze/remote:BUILD.fuchsia-zircon-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__fuchsia_zircon_sys__0_3_3",
+        url = "https://crates.io/api/v1/crates/fuchsia-zircon-sys/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7",
+        strip_prefix = "fuchsia-zircon-sys-0.3.3",
+        build_file = Label("//proto/raze/remote:BUILD.fuchsia-zircon-sys-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__futures__0_1_29",
+        url = "https://crates.io/api/v1/crates/futures/0.1.29/download",
+        type = "tar.gz",
+        sha256 = "1b980f2816d6ee8673b6517b52cb0e808a180efc92e5c19d02cdda79066703ef",
+        strip_prefix = "futures-0.1.29",
+        build_file = Label("//proto/raze/remote:BUILD.futures-0.1.29.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__futures_cpupool__0_1_8",
+        url = "https://crates.io/api/v1/crates/futures-cpupool/0.1.8/download",
+        type = "tar.gz",
+        sha256 = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4",
+        strip_prefix = "futures-cpupool-0.1.8",
+        build_file = Label("//proto/raze/remote:BUILD.futures-cpupool-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__grpc__0_6_2",
+        url = "https://crates.io/api/v1/crates/grpc/0.6.2/download",
+        type = "tar.gz",
+        sha256 = "2aaf1d741fe6f3413f1f9f71b99f5e4e26776d563475a8a53ce53a73a8534c1d",
+        strip_prefix = "grpc-0.6.2",
+        build_file = Label("//proto/raze/remote:BUILD.grpc-0.6.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__grpc_compiler__0_6_2",
+        url = "https://crates.io/api/v1/crates/grpc-compiler/0.6.2/download",
+        type = "tar.gz",
+        sha256 = "907274ce8ee7b40a0d0b0db09022ea22846a47cfb1fc8ad2c983c70001b4ffb1",
+        strip_prefix = "grpc-compiler-0.6.2",
+        build_file = Label("//proto/raze/remote:BUILD.grpc-compiler-0.6.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__hermit_abi__0_1_11",
+        url = "https://crates.io/api/v1/crates/hermit-abi/0.1.11/download",
+        type = "tar.gz",
+        sha256 = "8a0d737e0f947a1864e93d33fdef4af8445a00d1ed8dc0c8ddb73139ea6abf15",
+        strip_prefix = "hermit-abi-0.1.11",
+        build_file = Label("//proto/raze/remote:BUILD.hermit-abi-0.1.11.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__httpbis__0_7_0",
+        url = "https://crates.io/api/v1/crates/httpbis/0.7.0/download",
+        type = "tar.gz",
+        sha256 = "7689cfa896b2a71da4f16206af167542b75d242b6906313e53857972a92d5614",
+        strip_prefix = "httpbis-0.7.0",
+        build_file = Label("//proto/raze/remote:BUILD.httpbis-0.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__iovec__0_1_4",
+        url = "https://crates.io/api/v1/crates/iovec/0.1.4/download",
+        type = "tar.gz",
+        sha256 = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e",
+        strip_prefix = "iovec-0.1.4",
+        build_file = Label("//proto/raze/remote:BUILD.iovec-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__kernel32_sys__0_2_2",
+        url = "https://crates.io/api/v1/crates/kernel32-sys/0.2.2/download",
+        type = "tar.gz",
+        sha256 = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d",
+        strip_prefix = "kernel32-sys-0.2.2",
+        build_file = Label("//proto/raze/remote:BUILD.kernel32-sys-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//proto/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__libc__0_2_69",
+        url = "https://crates.io/api/v1/crates/libc/0.2.69/download",
+        type = "tar.gz",
+        sha256 = "99e85c08494b21a9054e7fe1374a732aeadaff3980b6990b94bfd3a70f690005",
+        strip_prefix = "libc-0.2.69",
+        build_file = Label("//proto/raze/remote:BUILD.libc-0.2.69.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__lock_api__0_3_4",
+        url = "https://crates.io/api/v1/crates/lock_api/0.3.4/download",
+        type = "tar.gz",
+        sha256 = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75",
+        strip_prefix = "lock_api-0.3.4",
+        build_file = Label("//proto/raze/remote:BUILD.lock_api-0.3.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__log__0_3_9",
+        url = "https://crates.io/api/v1/crates/log/0.3.9/download",
+        type = "tar.gz",
+        sha256 = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b",
+        strip_prefix = "log-0.3.9",
+        build_file = Label("//proto/raze/remote:BUILD.log-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__log__0_4_6",
+        url = "https://crates.io/api/v1/crates/log/0.4.6/download",
+        type = "tar.gz",
+        sha256 = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6",
+        strip_prefix = "log-0.4.6",
+        build_file = Label("//proto/raze/remote:BUILD.log-0.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__maybe_uninit__2_0_0",
+        url = "https://crates.io/api/v1/crates/maybe-uninit/2.0.0/download",
+        type = "tar.gz",
+        sha256 = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00",
+        strip_prefix = "maybe-uninit-2.0.0",
+        build_file = Label("//proto/raze/remote:BUILD.maybe-uninit-2.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__memoffset__0_5_4",
+        url = "https://crates.io/api/v1/crates/memoffset/0.5.4/download",
+        type = "tar.gz",
+        sha256 = "b4fc2c02a7e374099d4ee95a193111f72d2110197fe200272371758f6c3643d8",
+        strip_prefix = "memoffset-0.5.4",
+        build_file = Label("//proto/raze/remote:BUILD.memoffset-0.5.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__mio__0_6_21",
+        url = "https://crates.io/api/v1/crates/mio/0.6.21/download",
+        type = "tar.gz",
+        sha256 = "302dec22bcf6bae6dfb69c647187f4b4d0fb6f535521f7bc022430ce8e12008f",
+        strip_prefix = "mio-0.6.21",
+        build_file = Label("//proto/raze/remote:BUILD.mio-0.6.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__mio_uds__0_6_7",
+        url = "https://crates.io/api/v1/crates/mio-uds/0.6.7/download",
+        type = "tar.gz",
+        sha256 = "966257a94e196b11bb43aca423754d87429960a768de9414f3691d6957abf125",
+        strip_prefix = "mio-uds-0.6.7",
+        build_file = Label("//proto/raze/remote:BUILD.mio-uds-0.6.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__miow__0_2_1",
+        url = "https://crates.io/api/v1/crates/miow/0.2.1/download",
+        type = "tar.gz",
+        sha256 = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919",
+        strip_prefix = "miow-0.2.1",
+        build_file = Label("//proto/raze/remote:BUILD.miow-0.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__net2__0_2_33",
+        url = "https://crates.io/api/v1/crates/net2/0.2.33/download",
+        type = "tar.gz",
+        sha256 = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88",
+        strip_prefix = "net2-0.2.33",
+        build_file = Label("//proto/raze/remote:BUILD.net2-0.2.33.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__num_cpus__1_13_0",
+        url = "https://crates.io/api/v1/crates/num_cpus/1.13.0/download",
+        type = "tar.gz",
+        sha256 = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3",
+        strip_prefix = "num_cpus-1.13.0",
+        build_file = Label("//proto/raze/remote:BUILD.num_cpus-1.13.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__parking_lot__0_9_0",
+        url = "https://crates.io/api/v1/crates/parking_lot/0.9.0/download",
+        type = "tar.gz",
+        sha256 = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252",
+        strip_prefix = "parking_lot-0.9.0",
+        build_file = Label("//proto/raze/remote:BUILD.parking_lot-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__parking_lot_core__0_6_2",
+        url = "https://crates.io/api/v1/crates/parking_lot_core/0.6.2/download",
+        type = "tar.gz",
+        sha256 = "b876b1b9e7ac6e1a74a6da34d25c42e17e8862aa409cbbbdcfc8d86c6f3bc62b",
+        strip_prefix = "parking_lot_core-0.6.2",
+        build_file = Label("//proto/raze/remote:BUILD.parking_lot_core-0.6.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__protobuf__2_8_2",
+        url = "https://crates.io/api/v1/crates/protobuf/2.8.2/download",
+        type = "tar.gz",
+        sha256 = "70731852eec72c56d11226c8a5f96ad5058a3dab73647ca5f7ee351e464f2571",
+        strip_prefix = "protobuf-2.8.2",
+        patches = [
+            "@rules_rust//proto/raze/patch:protobuf-2.8.2.patch",
+        ],
+        patch_args = [
+            "-p1",
+        ],
+        build_file = Label("//proto/raze/remote:BUILD.protobuf-2.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__protobuf_codegen__2_8_2",
+        url = "https://crates.io/api/v1/crates/protobuf-codegen/2.8.2/download",
+        type = "tar.gz",
+        sha256 = "3d74b9cbbf2ac9a7169c85a3714ec16c51ee9ec7cfd511549527e9a7df720795",
+        strip_prefix = "protobuf-codegen-2.8.2",
+        build_file = Label("//proto/raze/remote:BUILD.protobuf-codegen-2.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__redox_syscall__0_1_56",
+        url = "https://crates.io/api/v1/crates/redox_syscall/0.1.56/download",
+        type = "tar.gz",
+        sha256 = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84",
+        strip_prefix = "redox_syscall-0.1.56",
+        build_file = Label("//proto/raze/remote:BUILD.redox_syscall-0.1.56.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__rustc_version__0_2_3",
+        url = "https://crates.io/api/v1/crates/rustc_version/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a",
+        strip_prefix = "rustc_version-0.2.3",
+        build_file = Label("//proto/raze/remote:BUILD.rustc_version-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__safemem__0_3_3",
+        url = "https://crates.io/api/v1/crates/safemem/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072",
+        strip_prefix = "safemem-0.3.3",
+        build_file = Label("//proto/raze/remote:BUILD.safemem-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__scoped_tls__0_1_2",
+        url = "https://crates.io/api/v1/crates/scoped-tls/0.1.2/download",
+        type = "tar.gz",
+        sha256 = "332ffa32bf586782a3efaeb58f127980944bbc8c4d6913a86107ac2a5ab24b28",
+        strip_prefix = "scoped-tls-0.1.2",
+        build_file = Label("//proto/raze/remote:BUILD.scoped-tls-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__scopeguard__1_1_0",
+        url = "https://crates.io/api/v1/crates/scopeguard/1.1.0/download",
+        type = "tar.gz",
+        sha256 = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd",
+        strip_prefix = "scopeguard-1.1.0",
+        build_file = Label("//proto/raze/remote:BUILD.scopeguard-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__semver__0_9_0",
+        url = "https://crates.io/api/v1/crates/semver/0.9.0/download",
+        type = "tar.gz",
+        sha256 = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403",
+        strip_prefix = "semver-0.9.0",
+        build_file = Label("//proto/raze/remote:BUILD.semver-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__semver_parser__0_7_0",
+        url = "https://crates.io/api/v1/crates/semver-parser/0.7.0/download",
+        type = "tar.gz",
+        sha256 = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3",
+        strip_prefix = "semver-parser-0.7.0",
+        build_file = Label("//proto/raze/remote:BUILD.semver-parser-0.7.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__slab__0_3_0",
+        url = "https://crates.io/api/v1/crates/slab/0.3.0/download",
+        type = "tar.gz",
+        sha256 = "17b4fcaed89ab08ef143da37bc52adbcc04d4a69014f4c1208d6b51f0c47bc23",
+        strip_prefix = "slab-0.3.0",
+        build_file = Label("//proto/raze/remote:BUILD.slab-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__slab__0_4_2",
+        url = "https://crates.io/api/v1/crates/slab/0.4.2/download",
+        type = "tar.gz",
+        sha256 = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8",
+        strip_prefix = "slab-0.4.2",
+        build_file = Label("//proto/raze/remote:BUILD.slab-0.4.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__smallvec__0_6_13",
+        url = "https://crates.io/api/v1/crates/smallvec/0.6.13/download",
+        type = "tar.gz",
+        sha256 = "f7b0758c52e15a8b5e3691eae6cc559f08eee9406e548a4477ba4e67770a82b6",
+        strip_prefix = "smallvec-0.6.13",
+        build_file = Label("//proto/raze/remote:BUILD.smallvec-0.6.13.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tls_api__0_1_22",
+        url = "https://crates.io/api/v1/crates/tls-api/0.1.22/download",
+        type = "tar.gz",
+        sha256 = "049c03787a0595182357fbd487577947f4351b78ce20c3668f6d49f17feb13d1",
+        strip_prefix = "tls-api-0.1.22",
+        build_file = Label("//proto/raze/remote:BUILD.tls-api-0.1.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tls_api_stub__0_1_22",
+        url = "https://crates.io/api/v1/crates/tls-api-stub/0.1.22/download",
+        type = "tar.gz",
+        sha256 = "c9a0cc8c149724db9de7d73a0e1bc80b1a74f5394f08c6f301e11f9c35fa061e",
+        strip_prefix = "tls-api-stub-0.1.22",
+        build_file = Label("//proto/raze/remote:BUILD.tls-api-stub-0.1.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio__0_1_22",
+        url = "https://crates.io/api/v1/crates/tokio/0.1.22/download",
+        type = "tar.gz",
+        sha256 = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6",
+        strip_prefix = "tokio-0.1.22",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-0.1.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_codec__0_1_2",
+        url = "https://crates.io/api/v1/crates/tokio-codec/0.1.2/download",
+        type = "tar.gz",
+        sha256 = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b",
+        strip_prefix = "tokio-codec-0.1.2",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-codec-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_core__0_1_17",
+        url = "https://crates.io/api/v1/crates/tokio-core/0.1.17/download",
+        type = "tar.gz",
+        sha256 = "aeeffbbb94209023feaef3c196a41cbcdafa06b4a6f893f68779bb5e53796f71",
+        strip_prefix = "tokio-core-0.1.17",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-core-0.1.17.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_current_thread__0_1_7",
+        url = "https://crates.io/api/v1/crates/tokio-current-thread/0.1.7/download",
+        type = "tar.gz",
+        sha256 = "b1de0e32a83f131e002238d7ccde18211c0a5397f60cbfffcb112868c2e0e20e",
+        strip_prefix = "tokio-current-thread-0.1.7",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-current-thread-0.1.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_executor__0_1_10",
+        url = "https://crates.io/api/v1/crates/tokio-executor/0.1.10/download",
+        type = "tar.gz",
+        sha256 = "fb2d1b8f4548dbf5e1f7818512e9c406860678f29c300cdf0ebac72d1a3a1671",
+        strip_prefix = "tokio-executor-0.1.10",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-executor-0.1.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_fs__0_1_7",
+        url = "https://crates.io/api/v1/crates/tokio-fs/0.1.7/download",
+        type = "tar.gz",
+        sha256 = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4",
+        strip_prefix = "tokio-fs-0.1.7",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-fs-0.1.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_io__0_1_13",
+        url = "https://crates.io/api/v1/crates/tokio-io/0.1.13/download",
+        type = "tar.gz",
+        sha256 = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674",
+        strip_prefix = "tokio-io-0.1.13",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-io-0.1.13.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_reactor__0_1_12",
+        url = "https://crates.io/api/v1/crates/tokio-reactor/0.1.12/download",
+        type = "tar.gz",
+        sha256 = "09bc590ec4ba8ba87652da2068d150dcada2cfa2e07faae270a5e0409aa51351",
+        strip_prefix = "tokio-reactor-0.1.12",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-reactor-0.1.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_sync__0_1_8",
+        url = "https://crates.io/api/v1/crates/tokio-sync/0.1.8/download",
+        type = "tar.gz",
+        sha256 = "edfe50152bc8164fcc456dab7891fa9bf8beaf01c5ee7e1dd43a397c3cf87dee",
+        strip_prefix = "tokio-sync-0.1.8",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-sync-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_tcp__0_1_4",
+        url = "https://crates.io/api/v1/crates/tokio-tcp/0.1.4/download",
+        type = "tar.gz",
+        sha256 = "98df18ed66e3b72e742f185882a9e201892407957e45fbff8da17ae7a7c51f72",
+        strip_prefix = "tokio-tcp-0.1.4",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-tcp-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_threadpool__0_1_18",
+        url = "https://crates.io/api/v1/crates/tokio-threadpool/0.1.18/download",
+        type = "tar.gz",
+        sha256 = "df720b6581784c118f0eb4310796b12b1d242a7eb95f716a8367855325c25f89",
+        strip_prefix = "tokio-threadpool-0.1.18",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-threadpool-0.1.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_timer__0_1_2",
+        url = "https://crates.io/api/v1/crates/tokio-timer/0.1.2/download",
+        type = "tar.gz",
+        sha256 = "6131e780037787ff1b3f8aad9da83bca02438b72277850dd6ad0d455e0e20efc",
+        strip_prefix = "tokio-timer-0.1.2",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-timer-0.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_timer__0_2_13",
+        url = "https://crates.io/api/v1/crates/tokio-timer/0.2.13/download",
+        type = "tar.gz",
+        sha256 = "93044f2d313c95ff1cb7809ce9a7a05735b012288a888b62d4434fd58c94f296",
+        strip_prefix = "tokio-timer-0.2.13",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-timer-0.2.13.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_tls_api__0_1_22",
+        url = "https://crates.io/api/v1/crates/tokio-tls-api/0.1.22/download",
+        type = "tar.gz",
+        sha256 = "68d0e040d5b1f4cfca70ec4f371229886a5de5bb554d272a4a8da73004a7b2c9",
+        strip_prefix = "tokio-tls-api-0.1.22",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-tls-api-0.1.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_udp__0_1_6",
+        url = "https://crates.io/api/v1/crates/tokio-udp/0.1.6/download",
+        type = "tar.gz",
+        sha256 = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82",
+        strip_prefix = "tokio-udp-0.1.6",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-udp-0.1.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_uds__0_1_7",
+        url = "https://crates.io/api/v1/crates/tokio-uds/0.1.7/download",
+        type = "tar.gz",
+        sha256 = "65ae5d255ce739e8537221ed2942e0445f4b3b813daebac1c0050ddaaa3587f9",
+        strip_prefix = "tokio-uds-0.1.7",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-uds-0.1.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__tokio_uds__0_2_6",
+        url = "https://crates.io/api/v1/crates/tokio-uds/0.2.6/download",
+        type = "tar.gz",
+        sha256 = "5076db410d6fdc6523df7595447629099a1fdc47b3d9f896220780fa48faf798",
+        strip_prefix = "tokio-uds-0.2.6",
+        build_file = Label("//proto/raze/remote:BUILD.tokio-uds-0.2.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__unix_socket__0_5_0",
+        url = "https://crates.io/api/v1/crates/unix_socket/0.5.0/download",
+        type = "tar.gz",
+        sha256 = "6aa2700417c405c38f5e6902d699345241c28c0b7ade4abaad71e35a87eb1564",
+        strip_prefix = "unix_socket-0.5.0",
+        build_file = Label("//proto/raze/remote:BUILD.unix_socket-0.5.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__void__1_0_2",
+        url = "https://crates.io/api/v1/crates/void/1.0.2/download",
+        type = "tar.gz",
+        sha256 = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d",
+        strip_prefix = "void-1.0.2",
+        build_file = Label("//proto/raze/remote:BUILD.void-1.0.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__winapi__0_2_8",
+        url = "https://crates.io/api/v1/crates/winapi/0.2.8/download",
+        type = "tar.gz",
+        sha256 = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a",
+        strip_prefix = "winapi-0.2.8",
+        build_file = Label("//proto/raze/remote:BUILD.winapi-0.2.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__winapi__0_3_8",
+        url = "https://crates.io/api/v1/crates/winapi/0.3.8/download",
+        type = "tar.gz",
+        sha256 = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6",
+        strip_prefix = "winapi-0.3.8",
+        build_file = Label("//proto/raze/remote:BUILD.winapi-0.3.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__winapi_build__0_1_1",
+        url = "https://crates.io/api/v1/crates/winapi-build/0.1.1/download",
+        type = "tar.gz",
+        sha256 = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc",
+        strip_prefix = "winapi-build-0.1.1",
+        build_file = Label("//proto/raze/remote:BUILD.winapi-build-0.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__winapi_i686_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("//proto/raze/remote:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__winapi_x86_64_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("//proto/raze/remote:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_proto__ws2_32_sys__0_2_1",
+        url = "https://crates.io/api/v1/crates/ws2_32-sys/0.2.1/download",
+        type = "tar.gz",
+        sha256 = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e",
+        strip_prefix = "ws2_32-sys-0.2.1",
+        build_file = Label("//proto/raze/remote:BUILD.ws2_32-sys-0.2.1.bazel"),
+    )
diff --git a/third_party/rules_rust/proto/raze/patch/BUILD.bazel b/third_party/rules_rust/proto/raze/patch/BUILD.bazel
new file mode 100644
index 0000000..a5e9d2a
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/patch/BUILD.bazel
@@ -0,0 +1,8 @@
+package(default_visibility = ["//proto/raze:__subpackages__"])
+
+filegroup(
+    name = "patches",
+    srcs = [
+        "protobuf-2.8.2.patch",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/patch/README.md b/third_party/rules_rust/proto/raze/patch/README.md
new file mode 100644
index 0000000..2cd05d7
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/patch/README.md
@@ -0,0 +1,31 @@
+# Patches
+
+Cargo raze, in its remote mode allows for patches to be applied to a repository
+before building it with rustc. It is advisable to use this functionality
+sparingly, if at all. Also note that the patch is applied after all of the
+dependency resolution has been completed by cargo raze, and that patching the
+version of a dependency will not cause cargo raze to update that dependency in
+the BUILD file.
+
+The patch itself can be generated using git or another tool. The output of git
+diff requires the `-p1` option to remove the leading `/` from the git diff patch
+format.
+
+## protobuf-2.8.2
+
+The protobuf crate from the rust-protobuf repository introduced a build.rs
+script in the 2.x.x series. This generates a small version.rs file that would be
+[included into lib.rs](https://github.com/stepancheg/rust-protobuf/blob/v2.8/protobuf/src/lib.rs#L122).
+However, the build.rs file requires a number of environment variables, normally
+provided by cargo to the build file. Cargo raze does not provide these
+variables. The resulting code includes a version string and version identifier.
+The version string is then used by protobuf-codegen to generate code refering to
+the identifier in the protobuf library. The use can be seen
+[here](https://github.com/stepancheg/rust-protobuf/blob/v2.8/protobuf-codegen/src/lib.rs#L160).
+This is to enforce at compile time that the version of protobuf-codegen matches
+the version of the protobuf crate.
+
+For this crate, the patch that is applied is replacing the include! macro with
+what would be generated by the build.rs file. This lets us avoid running the
+build file altogether, at the expense of having to update the patch for every
+version.
diff --git a/third_party/rules_rust/proto/raze/patch/protobuf-2.8.2.patch b/third_party/rules_rust/proto/raze/patch/protobuf-2.8.2.patch
new file mode 100644
index 0000000..c81a911
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/patch/protobuf-2.8.2.patch
@@ -0,0 +1,13 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index b487e6e..38b7f7c 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -119,4 +119,7 @@ pub const VERSION: &str = "";
+ #[cfg(never)]
+ #[doc(hidden)]
+ pub const VERSION_IDENT: &str = "";
+-include!(concat!(env!("OUT_DIR"), "/version.rs"));
++pub const VERSION: &'static str = "2.8.2";
++#[doc(hidden)]
++pub const VERSION_IDENT: &'static str = "VERSION_2_8_2";
++pub const VERSION_2_8_2: () = ();
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.autocfg-1.0.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.autocfg-1.0.0.bazel
new file mode 100644
index 0000000..9682987
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.autocfg-1.0.0.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "integers" with type "example" omitted
+
+# Unsupported target "paths" with type "example" omitted
+
+# Unsupported target "traits" with type "example" omitted
+
+# Unsupported target "versions" with type "example" omitted
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "rustflags" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.base64-0.9.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.base64-0.9.3.bazel
new file mode 100644
index 0000000..0ff1374
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.base64-0.9.3.bazel
@@ -0,0 +1,67 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmarks" with type "bench" omitted
+
+# Unsupported target "make_tables" with type "example" omitted
+
+rust_library(
+    name = "base64",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__byteorder__1_3_4//:byteorder",
+        "@rules_rust_proto__safemem__0_3_3//:safemem",
+    ],
+)
+
+# Unsupported target "decode" with type "test" omitted
+
+# Unsupported target "encode" with type "test" omitted
+
+# Unsupported target "helpers" with type "test" omitted
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.bitflags-1.2.1.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.bitflags-1.2.1.bazel
new file mode 100644
index 0000000..7d99f2d
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.bitflags-1.2.1.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.byteorder-1.3.4.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.byteorder-1.3.4.bazel
new file mode 100644
index 0000000..861495b
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.byteorder-1.3.4.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "byteorder",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.3.4",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.bytes-0.4.12.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.bytes-0.4.12.bazel
new file mode 100644
index 0000000..ca3b7ae
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.bytes-0.4.12.bazel
@@ -0,0 +1,77 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "bytes" with type "bench" omitted
+
+rust_library(
+    name = "bytes",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.12",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__byteorder__1_3_4//:byteorder",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+    ],
+)
+
+# Unsupported target "test_buf" with type "test" omitted
+
+# Unsupported target "test_buf_mut" with type "test" omitted
+
+# Unsupported target "test_bytes" with type "test" omitted
+
+# Unsupported target "test_chain" with type "test" omitted
+
+# Unsupported target "test_debug" with type "test" omitted
+
+# Unsupported target "test_from_buf" with type "test" omitted
+
+# Unsupported target "test_iter" with type "test" omitted
+
+# Unsupported target "test_reader" with type "test" omitted
+
+# Unsupported target "test_serde" with type "test" omitted
+
+# Unsupported target "test_take" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.cfg-if-0.1.10.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.cfg-if-0.1.10.bazel
new file mode 100644
index 0000000..792b241
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.cfg-if-0.1.10.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.10",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.cloudabi-0.0.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.cloudabi-0.0.3.bazel
new file mode 100644
index 0000000..acf75d1
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.cloudabi-0.0.3.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "restricted",  # BSD-2-Clause from expression "BSD-2-Clause"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cloudabi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "bitflags",
+        "default",
+    ],
+    crate_root = "cloudabi.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.0.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bitflags__1_2_1//:bitflags",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-deque-0.7.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-deque-0.7.3.bazel
new file mode 100644
index 0000000..4e517b6
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-deque-0.7.3.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "crossbeam_deque",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__crossbeam_epoch__0_8_2//:crossbeam_epoch",
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__maybe_uninit__2_0_0//:maybe_uninit",
+    ],
+)
+
+# Unsupported target "fifo" with type "test" omitted
+
+# Unsupported target "injector" with type "test" omitted
+
+# Unsupported target "lifo" with type "test" omitted
+
+# Unsupported target "steal" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-epoch-0.8.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-epoch-0.8.2.bazel
new file mode 100644
index 0000000..6749a99
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-epoch-0.8.2.bazel
@@ -0,0 +1,74 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "defer" with type "bench" omitted
+
+# Unsupported target "flush" with type "bench" omitted
+
+# Unsupported target "pin" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+# Unsupported target "sanitize" with type "example" omitted
+
+# Unsupported target "treiber_stack" with type "example" omitted
+
+rust_library(
+    name = "crossbeam_epoch",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_proto__maybe_uninit__2_0_0//:maybe_uninit",
+        "@rules_rust_proto__memoffset__0_5_4//:memoffset",
+        "@rules_rust_proto__scopeguard__1_1_0//:scopeguard",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-queue-0.2.1.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-queue-0.2.1.bazel
new file mode 100644
index 0000000..fac28d3
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-queue-0.2.1.bazel
@@ -0,0 +1,61 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR (Apache-2.0 AND BSD-2-Clause)"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "crossbeam_queue",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+    ],
+)
+
+# Unsupported target "array_queue" with type "test" omitted
+
+# Unsupported target "seg_queue" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-utils-0.7.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-utils-0.7.2.bazel
new file mode 100644
index 0000000..61f09e2
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.crossbeam-utils-0.7.2.bazel
@@ -0,0 +1,74 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "atomic_cell" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "crossbeam_utils",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__lazy_static__1_4_0//:lazy_static",
+    ],
+)
+
+# Unsupported target "atomic_cell" with type "test" omitted
+
+# Unsupported target "cache_padded" with type "test" omitted
+
+# Unsupported target "parker" with type "test" omitted
+
+# Unsupported target "sharded_lock" with type "test" omitted
+
+# Unsupported target "thread" with type "test" omitted
+
+# Unsupported target "wait_group" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.fnv-1.0.6.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.fnv-1.0.6.bazel
new file mode 100644
index 0000000..ddac662
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.fnv-1.0.6.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "fnv",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.6",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-0.3.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-0.3.3.bazel
new file mode 100644
index 0000000..69c1ae7
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-0.3.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # BSD-3-Clause from expression "BSD-3-Clause"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "fuchsia_zircon",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bitflags__1_2_1//:bitflags",
+        "@rules_rust_proto__fuchsia_zircon_sys__0_3_3//:fuchsia_zircon_sys",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-sys-0.3.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-sys-0.3.3.bazel
new file mode 100644
index 0000000..ce34aa2
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.fuchsia-zircon-sys-0.3.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # BSD-3-Clause from expression "BSD-3-Clause"
+])
+
+# Generated Targets
+
+# Unsupported target "hello" with type "example" omitted
+
+rust_library(
+    name = "fuchsia_zircon_sys",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.futures-0.1.29.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.futures-0.1.29.bazel
new file mode 100644
index 0000000..8ae5d86
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.futures-0.1.29.bazel
@@ -0,0 +1,118 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bilock" with type "bench" omitted
+
+# Unsupported target "futures_unordered" with type "bench" omitted
+
+# Unsupported target "poll" with type "bench" omitted
+
+# Unsupported target "sync_mpsc" with type "bench" omitted
+
+# Unsupported target "thread_notify" with type "bench" omitted
+
+rust_library(
+    name = "futures",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "use_std",
+        "with-deprecated",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.29",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "all" with type "test" omitted
+
+# Unsupported target "bilock" with type "test" omitted
+
+# Unsupported target "buffer_unordered" with type "test" omitted
+
+# Unsupported target "channel" with type "test" omitted
+
+# Unsupported target "eager_drop" with type "test" omitted
+
+# Unsupported target "eventual" with type "test" omitted
+
+# Unsupported target "fuse" with type "test" omitted
+
+# Unsupported target "future_flatten_stream" with type "test" omitted
+
+# Unsupported target "futures_ordered" with type "test" omitted
+
+# Unsupported target "futures_unordered" with type "test" omitted
+
+# Unsupported target "inspect" with type "test" omitted
+
+# Unsupported target "mpsc" with type "test" omitted
+
+# Unsupported target "mpsc-close" with type "test" omitted
+
+# Unsupported target "oneshot" with type "test" omitted
+
+# Unsupported target "ready_queue" with type "test" omitted
+
+# Unsupported target "recurse" with type "test" omitted
+
+# Unsupported target "select_all" with type "test" omitted
+
+# Unsupported target "select_ok" with type "test" omitted
+
+# Unsupported target "shared" with type "test" omitted
+
+# Unsupported target "sink" with type "test" omitted
+
+# Unsupported target "split" with type "test" omitted
+
+# Unsupported target "stream" with type "test" omitted
+
+# Unsupported target "stream_catch_unwind" with type "test" omitted
+
+# Unsupported target "unfold" with type "test" omitted
+
+# Unsupported target "unsync" with type "test" omitted
+
+# Unsupported target "unsync-oneshot" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.futures-cpupool-0.1.8.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.futures-cpupool-0.1.8.bazel
new file mode 100644
index 0000000..0543a19
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.futures-cpupool-0.1.8.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "futures_cpupool",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "with-deprecated",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.8",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__num_cpus__1_13_0//:num_cpus",
+    ],
+)
+
+# Unsupported target "smoke" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.grpc-0.6.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.grpc-0.6.2.bazel
new file mode 100644
index 0000000..c844b62
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.grpc-0.6.2.bazel
@@ -0,0 +1,71 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "grpc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__base64__0_9_3//:base64",
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__futures_cpupool__0_1_8//:futures_cpupool",
+        "@rules_rust_proto__httpbis__0_7_0//:httpbis",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+        "@rules_rust_proto__tls_api__0_1_22//:tls_api",
+        "@rules_rust_proto__tls_api_stub__0_1_22//:tls_api_stub",
+        "@rules_rust_proto__tokio_core__0_1_17//:tokio_core",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_tls_api__0_1_22//:tokio_tls_api",
+    ],
+)
+
+# Unsupported target "client" with type "test" omitted
+
+# Unsupported target "server" with type "test" omitted
+
+# Unsupported target "simple" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.grpc-compiler-0.6.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.grpc-compiler-0.6.2.bazel
new file mode 100644
index 0000000..8dab3a3
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.grpc-compiler-0.6.2.bazel
@@ -0,0 +1,81 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_protoc_gen_rust_grpc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/protoc-gen-rust-grpc.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.2",
+    # buildifier: leave-alone
+    deps = [
+        ":grpc_compiler",
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+        "@rules_rust_proto__protobuf_codegen__2_8_2//:protobuf_codegen",
+    ],
+)
+
+rust_library(
+    name = "grpc_compiler",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+        "@rules_rust_proto__protobuf_codegen__2_8_2//:protobuf_codegen",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.hermit-abi-0.1.11.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.hermit-abi-0.1.11.bazel
new file mode 100644
index 0000000..6c5b997
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.hermit-abi-0.1.11.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.11",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__libc__0_2_69//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.httpbis-0.7.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.httpbis-0.7.0.bazel
new file mode 100644
index 0000000..f329e41
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.httpbis-0.7.0.bazel
@@ -0,0 +1,99 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "client_server" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+# Unsupported target "client" with type "example" omitted
+
+# Unsupported target "server" with type "example" omitted
+
+rust_library(
+    name = "httpbis",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__futures_cpupool__0_1_8//:futures_cpupool",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__net2__0_2_33//:net2",
+        "@rules_rust_proto__tls_api__0_1_22//:tls_api",
+        "@rules_rust_proto__tls_api_stub__0_1_22//:tls_api_stub",
+        "@rules_rust_proto__tokio_core__0_1_17//:tokio_core",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_timer__0_1_2//:tokio_timer",
+        "@rules_rust_proto__tokio_tls_api__0_1_22//:tokio_tls_api",
+        "@rules_rust_proto__void__1_0_2//:void",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__tokio_uds__0_1_7//:tokio_uds",
+            "@rules_rust_proto__unix_socket__0_5_0//:unix_socket",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.iovec-0.1.4.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.iovec-0.1.4.bazel
new file mode 100644
index 0000000..9fcb172
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.iovec-0.1.4.bazel
@@ -0,0 +1,78 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "iovec",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.4",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__libc__0_2_69//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.kernel32-sys-0.2.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.kernel32-sys-0.2.2.bazel
new file mode 100644
index 0000000..4103c40
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.kernel32-sys-0.2.2.bazel
@@ -0,0 +1,65 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+alias(
+    name = "kernel32_sys",
+    actual = ":kernel32",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+rust_library(
+    name = "kernel32",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__winapi__0_2_8//:winapi",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..1cf4320
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=lazy_static_heap_impl",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.libc-0.2.69.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.libc-0.2.69.bazel
new file mode 100644
index 0000000..1116822
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.libc-0.2.69.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.69",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.lock_api-0.3.4.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.lock_api-0.3.4.bazel
new file mode 100644
index 0000000..c4fc23f
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.lock_api-0.3.4.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lock_api",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__scopeguard__1_1_0//:scopeguard",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.log-0.3.9.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.log-0.3.9.bazel
new file mode 100644
index 0000000..8a8aad4
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.log-0.3.9.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__log__0_4_6//:log",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.log-0.4.6.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.log-0.4.6.bazel
new file mode 100644
index 0000000..a3a7a10
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.log-0.4.6.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.6",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.maybe-uninit-2.0.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.maybe-uninit-2.0.0.bazel
new file mode 100644
index 0000000..c991af2
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.maybe-uninit-2.0.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "maybe_uninit",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "doesnt_drop" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.memoffset-0.5.4.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.memoffset-0.5.4.bazel
new file mode 100644
index 0000000..cd38911
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.memoffset-0.5.4.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "memoffset",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.5.4",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.mio-0.6.21.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.mio-0.6.21.bazel
new file mode 100644
index 0000000..e8c6e95
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.mio-0.6.21.bazel
@@ -0,0 +1,100 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "bench_poll" with type "bench" omitted
+
+rust_library(
+    name = "mio",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "default",
+        "with-deprecated",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.21",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__net2__0_2_33//:net2",
+        "@rules_rust_proto__slab__0_4_2//:slab",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__libc__0_2_69//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_proto__kernel32_sys__0_2_2//:kernel32_sys",
+            "@rules_rust_proto__miow__0_2_1//:miow",
+            "@rules_rust_proto__winapi__0_2_8//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.mio-uds-0.6.7.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.mio-uds-0.6.7.bazel
new file mode 100644
index 0000000..2fada07
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.mio-uds-0.6.7.bazel
@@ -0,0 +1,84 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "mio_uds",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.7",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__iovec__0_1_4//:iovec",
+            "@rules_rust_proto__libc__0_2_69//:libc",
+            "@rules_rust_proto__mio__0_6_21//:mio",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "echo" with type "test" omitted
+
+# Unsupported target "smoke" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.miow-0.2.1.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.miow-0.2.1.bazel
new file mode 100644
index 0000000..766f4cd
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.miow-0.2.1.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "miow",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__kernel32_sys__0_2_2//:kernel32_sys",
+        "@rules_rust_proto__net2__0_2_33//:net2",
+        "@rules_rust_proto__winapi__0_2_8//:winapi",
+        "@rules_rust_proto__ws2_32_sys__0_2_1//:ws2_32_sys",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.net2-0.2.33.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.net2-0.2.33.bazel
new file mode 100644
index 0000000..2d13ae7
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.net2-0.2.33.bazel
@@ -0,0 +1,92 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "net2",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "default",
+        "duration",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.33",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+    ] + selects.with_or({
+        # cfg(any(target_os = "redox", unix))
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__libc__0_2_69//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_proto__winapi__0_3_8//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "all" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.num_cpus-1.13.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.num_cpus-1.13.0.bazel
new file mode 100644
index 0000000..5aee7b9
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.num_cpus-1.13.0.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "values" with type "example" omitted
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.13.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__libc__0_2_69//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot-0.9.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot-0.9.0.bazel
new file mode 100644
index 0000000..2ce210f
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot-0.9.0.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "parking_lot",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__lock_api__0_3_4//:lock_api",
+        "@rules_rust_proto__parking_lot_core__0_6_2//:parking_lot_core",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot_core-0.6.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot_core-0.6.2.bazel
new file mode 100644
index 0000000..843a86b
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.parking_lot_core-0.6.2.bazel
@@ -0,0 +1,91 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "parking_lot_core",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__smallvec__0_6_13//:smallvec",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__libc__0_2_69//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_proto__winapi__0_3_8//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-2.8.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-2.8.2.bazel
new file mode 100644
index 0000000..d27c2d6
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-2.8.2.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "coded_input_stream" with type "bench" omitted
+
+# Unsupported target "coded_output_stream" with type "bench" omitted
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "protobuf",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "bytes",
+        "with-bytes",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.8.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-codegen-2.8.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-codegen-2.8.2.bazel
new file mode 100644
index 0000000..eef555a
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.protobuf-codegen-2.8.2.bazel
@@ -0,0 +1,104 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_protobuf_bin_gen_rust_do_not_use",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/protobuf-bin-gen-rust-do-not-use.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.8.2",
+    # buildifier: leave-alone
+    deps = [
+        ":protobuf_codegen",
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+    ],
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_protoc_gen_rust",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/protoc-gen-rust.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.8.2",
+    # buildifier: leave-alone
+    deps = [
+        ":protobuf_codegen",
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+    ],
+)
+
+rust_library(
+    name = "protobuf_codegen",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.8.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__protobuf__2_8_2//:protobuf",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.redox_syscall-0.1.56.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.redox_syscall-0.1.56.bazel
new file mode 100644
index 0000000..553dc6f
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.redox_syscall-0.1.56.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+alias(
+    name = "redox_syscall",
+    actual = ":syscall",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+rust_library(
+    name = "syscall",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.56",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.rustc_version-0.2.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.rustc_version-0.2.3.bazel
new file mode 100644
index 0000000..671bffc
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.rustc_version-0.2.3.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rustc_version",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__semver__0_9_0//:semver",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.safemem-0.3.3.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.safemem-0.3.3.bazel
new file mode 100644
index 0000000..a3cb953
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.safemem-0.3.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "safemem",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.scoped-tls-0.1.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.scoped-tls-0.1.2.bazel
new file mode 100644
index 0000000..a6e593a
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.scoped-tls-0.1.2.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "scoped_tls",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.scopeguard-1.1.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.scopeguard-1.1.0.bazel
new file mode 100644
index 0000000..8d5533a
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.scopeguard-1.1.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "readme" with type "example" omitted
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.semver-0.9.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.semver-0.9.0.bazel
new file mode 100644
index 0000000..370211c
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.semver-0.9.0.bazel
@@ -0,0 +1,61 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "semver",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__semver_parser__0_7_0//:semver_parser",
+    ],
+)
+
+# Unsupported target "deprecation" with type "test" omitted
+
+# Unsupported target "regression" with type "test" omitted
+
+# Unsupported target "serde" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.semver-parser-0.7.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.semver-parser-0.7.0.bazel
new file mode 100644
index 0000000..9f91111
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.semver-parser-0.7.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "semver_parser",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.3.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.3.0.bazel
new file mode 100644
index 0000000..2af87d1
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.3.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "slab",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.4.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.4.2.bazel
new file mode 100644
index 0000000..85e61e3
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.slab-0.4.2.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "slab",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "slab" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.smallvec-0.6.13.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.smallvec-0.6.13.bazel
new file mode 100644
index 0000000..aeaedfd
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.smallvec-0.6.13.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "smallvec",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.13",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__maybe_uninit__2_0_0//:maybe_uninit",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-0.1.22.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-0.1.22.bazel
new file mode 100644
index 0000000..e75e72b
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-0.1.22.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tls_api",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.22",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__log__0_4_6//:log",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-stub-0.1.22.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-stub-0.1.22.bazel
new file mode 100644
index 0000000..71fe4cf
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tls-api-stub-0.1.22.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tls_api_stub",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.22",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__tls_api__0_1_22//:tls_api",
+        "@rules_rust_proto__void__1_0_2//:void",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-0.1.22.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-0.1.22.bazel
new file mode 100644
index 0000000..8c46d0c
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-0.1.22.bazel
@@ -0,0 +1,171 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "blocking" with type "example" omitted
+
+# Unsupported target "chat" with type "example" omitted
+
+# Unsupported target "chat-combinator" with type "example" omitted
+
+# Unsupported target "chat-combinator-current-thread" with type "example" omitted
+
+# Unsupported target "connect" with type "example" omitted
+
+# Unsupported target "echo" with type "example" omitted
+
+# Unsupported target "echo-udp" with type "example" omitted
+
+# Unsupported target "hello_world" with type "example" omitted
+
+# Unsupported target "manual-runtime" with type "example" omitted
+
+# Unsupported target "print_each_packet" with type "example" omitted
+
+# Unsupported target "proxy" with type "example" omitted
+
+# Unsupported target "tinydb" with type "example" omitted
+
+# Unsupported target "tinyhttp" with type "example" omitted
+
+# Unsupported target "udp-client" with type "example" omitted
+
+# Unsupported target "udp-codec" with type "example" omitted
+
+rust_library(
+    name = "tokio",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "bytes",
+        "codec",
+        "default",
+        "fs",
+        "io",
+        "mio",
+        "num_cpus",
+        "reactor",
+        "rt-full",
+        "sync",
+        "tcp",
+        "timer",
+        "tokio-codec",
+        "tokio-current-thread",
+        "tokio-executor",
+        "tokio-fs",
+        "tokio-io",
+        "tokio-reactor",
+        "tokio-sync",
+        "tokio-tcp",
+        "tokio-threadpool",
+        "tokio-timer",
+        "tokio-udp",
+        "tokio-uds",
+        "udp",
+        "uds",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.22",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__num_cpus__1_13_0//:num_cpus",
+        "@rules_rust_proto__tokio_codec__0_1_2//:tokio_codec",
+        "@rules_rust_proto__tokio_current_thread__0_1_7//:tokio_current_thread",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+        "@rules_rust_proto__tokio_fs__0_1_7//:tokio_fs",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_reactor__0_1_12//:tokio_reactor",
+        "@rules_rust_proto__tokio_sync__0_1_8//:tokio_sync",
+        "@rules_rust_proto__tokio_tcp__0_1_4//:tokio_tcp",
+        "@rules_rust_proto__tokio_threadpool__0_1_18//:tokio_threadpool",
+        "@rules_rust_proto__tokio_timer__0_2_13//:tokio_timer",
+        "@rules_rust_proto__tokio_udp__0_1_6//:tokio_udp",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_proto__tokio_uds__0_2_6//:tokio_uds",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "buffered" with type "test" omitted
+
+# Unsupported target "clock" with type "test" omitted
+
+# Unsupported target "drop-core" with type "test" omitted
+
+# Unsupported target "enumerate" with type "test" omitted
+
+# Unsupported target "global" with type "test" omitted
+
+# Unsupported target "length_delimited" with type "test" omitted
+
+# Unsupported target "line-frames" with type "test" omitted
+
+# Unsupported target "pipe-hup" with type "test" omitted
+
+# Unsupported target "reactor" with type "test" omitted
+
+# Unsupported target "runtime" with type "test" omitted
+
+# Unsupported target "timer" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-codec-0.1.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-codec-0.1.2.bazel
new file mode 100644
index 0000000..4a6e746
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-codec-0.1.2.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_codec",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+    ],
+)
+
+# Unsupported target "codecs" with type "test" omitted
+
+# Unsupported target "framed" with type "test" omitted
+
+# Unsupported target "framed_read" with type "test" omitted
+
+# Unsupported target "framed_write" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-core-0.1.17.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-core-0.1.17.bazel
new file mode 100644
index 0000000..77a8bc0
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-core-0.1.17.bazel
@@ -0,0 +1,118 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "latency" with type "bench" omitted
+
+# Unsupported target "mio-ops" with type "bench" omitted
+
+# Unsupported target "tcp" with type "bench" omitted
+
+# Unsupported target "chat" with type "example" omitted
+
+# Unsupported target "compress" with type "example" omitted
+
+# Unsupported target "connect" with type "example" omitted
+
+# Unsupported target "echo" with type "example" omitted
+
+# Unsupported target "echo-threads" with type "example" omitted
+
+# Unsupported target "echo-udp" with type "example" omitted
+
+# Unsupported target "hello" with type "example" omitted
+
+# Unsupported target "proxy" with type "example" omitted
+
+# Unsupported target "sink" with type "example" omitted
+
+# Unsupported target "tinydb" with type "example" omitted
+
+# Unsupported target "tinyhttp" with type "example" omitted
+
+# Unsupported target "udp-codec" with type "example" omitted
+
+rust_library(
+    name = "tokio_core",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.17",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__scoped_tls__0_1_2//:scoped_tls",
+        "@rules_rust_proto__tokio__0_1_22//:tokio",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_reactor__0_1_12//:tokio_reactor",
+        "@rules_rust_proto__tokio_timer__0_2_13//:tokio_timer",
+    ],
+)
+
+# Unsupported target "buffered" with type "test" omitted
+
+# Unsupported target "chain" with type "test" omitted
+
+# Unsupported target "echo" with type "test" omitted
+
+# Unsupported target "interval" with type "test" omitted
+
+# Unsupported target "limit" with type "test" omitted
+
+# Unsupported target "line-frames" with type "test" omitted
+
+# Unsupported target "pipe-hup" with type "test" omitted
+
+# Unsupported target "spawn" with type "test" omitted
+
+# Unsupported target "stream-buffered" with type "test" omitted
+
+# Unsupported target "tcp" with type "test" omitted
+
+# Unsupported target "timeout" with type "test" omitted
+
+# Unsupported target "udp" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-current-thread-0.1.7.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-current-thread-0.1.7.bazel
new file mode 100644
index 0000000..2a34fe3
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-current-thread-0.1.7.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_current_thread",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.7",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+    ],
+)
+
+# Unsupported target "current_thread" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-executor-0.1.10.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-executor-0.1.10.bazel
new file mode 100644
index 0000000..1e34e30
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-executor-0.1.10.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_executor",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.10",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+    ],
+)
+
+# Unsupported target "executor" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-fs-0.1.7.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-fs-0.1.7.bazel
new file mode 100644
index 0000000..1ade220
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-fs-0.1.7.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "std-echo" with type "example" omitted
+
+rust_library(
+    name = "tokio_fs",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.7",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_threadpool__0_1_18//:tokio_threadpool",
+    ],
+)
+
+# Unsupported target "dir" with type "test" omitted
+
+# Unsupported target "file" with type "test" omitted
+
+# Unsupported target "link" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-io-0.1.13.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-io-0.1.13.bazel
new file mode 100644
index 0000000..725cef6
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-io-0.1.13.bazel
@@ -0,0 +1,60 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_io",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.13",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__log__0_4_6//:log",
+    ],
+)
+
+# Unsupported target "async_read" with type "test" omitted
+
+# Unsupported target "length_delimited" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-reactor-0.1.12.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-reactor-0.1.12.bazel
new file mode 100644
index 0000000..79c60af
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-reactor-0.1.12.bazel
@@ -0,0 +1,66 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "basic" with type "bench" omitted
+
+rust_library(
+    name = "tokio_reactor",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.12",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__num_cpus__1_13_0//:num_cpus",
+        "@rules_rust_proto__parking_lot__0_9_0//:parking_lot",
+        "@rules_rust_proto__slab__0_4_2//:slab",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_sync__0_1_8//:tokio_sync",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-sync-0.1.8.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-sync-0.1.8.bazel
new file mode 100644
index 0000000..ceddbdd
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-sync-0.1.8.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "mpsc" with type "bench" omitted
+
+# Unsupported target "oneshot" with type "bench" omitted
+
+rust_library(
+    name = "tokio_sync",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.8",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__fnv__1_0_6//:fnv",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+    ],
+)
+
+# Unsupported target "atomic_task" with type "test" omitted
+
+# Unsupported target "errors" with type "test" omitted
+
+# Unsupported target "fuzz_atomic_task" with type "test" omitted
+
+# Unsupported target "fuzz_list" with type "test" omitted
+
+# Unsupported target "fuzz_mpsc" with type "test" omitted
+
+# Unsupported target "fuzz_oneshot" with type "test" omitted
+
+# Unsupported target "fuzz_semaphore" with type "test" omitted
+
+# Unsupported target "lock" with type "test" omitted
+
+# Unsupported target "mpsc" with type "test" omitted
+
+# Unsupported target "oneshot" with type "test" omitted
+
+# Unsupported target "semaphore" with type "test" omitted
+
+# Unsupported target "watch" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tcp-0.1.4.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tcp-0.1.4.bazel
new file mode 100644
index 0000000..1092a65
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tcp-0.1.4.bazel
@@ -0,0 +1,69 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_tcp",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_reactor__0_1_12//:tokio_reactor",
+    ],
+)
+
+# Unsupported target "chain" with type "test" omitted
+
+# Unsupported target "echo" with type "test" omitted
+
+# Unsupported target "limit" with type "test" omitted
+
+# Unsupported target "stream-buffered" with type "test" omitted
+
+# Unsupported target "tcp" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-threadpool-0.1.18.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-threadpool-0.1.18.bazel
new file mode 100644
index 0000000..00dc624
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-threadpool-0.1.18.bazel
@@ -0,0 +1,78 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "basic" with type "bench" omitted
+
+# Unsupported target "blocking" with type "bench" omitted
+
+# Unsupported target "depth" with type "bench" omitted
+
+# Unsupported target "depth" with type "example" omitted
+
+# Unsupported target "hello" with type "example" omitted
+
+rust_library(
+    name = "tokio_threadpool",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__crossbeam_deque__0_7_3//:crossbeam_deque",
+        "@rules_rust_proto__crossbeam_queue__0_2_1//:crossbeam_queue",
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__num_cpus__1_13_0//:num_cpus",
+        "@rules_rust_proto__slab__0_4_2//:slab",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+    ],
+)
+
+# Unsupported target "blocking" with type "test" omitted
+
+# Unsupported target "hammer" with type "test" omitted
+
+# Unsupported target "threadpool" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.1.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.1.2.bazel
new file mode 100644
index 0000000..8b27857
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.1.2.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_timer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__slab__0_3_0//:slab",
+    ],
+)
+
+# Unsupported target "support" with type "test" omitted
+
+# Unsupported target "test_timer" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.2.13.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.2.13.bazel
new file mode 100644
index 0000000..acabcae
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-timer-0.2.13.bazel
@@ -0,0 +1,73 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_timer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.13",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__crossbeam_utils__0_7_2//:crossbeam_utils",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__slab__0_4_2//:slab",
+        "@rules_rust_proto__tokio_executor__0_1_10//:tokio_executor",
+    ],
+)
+
+# Unsupported target "clock" with type "test" omitted
+
+# Unsupported target "deadline" with type "test" omitted
+
+# Unsupported target "delay" with type "test" omitted
+
+# Unsupported target "hammer" with type "test" omitted
+
+# Unsupported target "interval" with type "test" omitted
+
+# Unsupported target "queue" with type "test" omitted
+
+# Unsupported target "throttle" with type "test" omitted
+
+# Unsupported target "timeout" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tls-api-0.1.22.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tls-api-0.1.22.bazel
new file mode 100644
index 0000000..2332b94
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-tls-api-0.1.22.bazel
@@ -0,0 +1,60 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_tls_api",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.22",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__tls_api__0_1_22//:tls_api",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+    ],
+)
+
+# Unsupported target "bad" with type "test" omitted
+
+# Unsupported target "smoke" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-udp-0.1.6.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-udp-0.1.6.bazel
new file mode 100644
index 0000000..1cc5c69
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-udp-0.1.6.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_udp",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.6",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__tokio_codec__0_1_2//:tokio_codec",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_reactor__0_1_12//:tokio_reactor",
+    ],
+)
+
+# Unsupported target "udp" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.1.7.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.1.7.bazel
new file mode 100644
index 0000000..335ae6e
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.1.7.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_uds",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.7",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+        "@rules_rust_proto__libc__0_2_69//:libc",
+        "@rules_rust_proto__log__0_3_9//:log",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__mio_uds__0_6_7//:mio_uds",
+        "@rules_rust_proto__tokio_core__0_1_17//:tokio_core",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.2.6.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.2.6.bazel
new file mode 100644
index 0000000..1c45b1c
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.tokio-uds-0.2.6.bazel
@@ -0,0 +1,67 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tokio_uds",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.6",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__bytes__0_4_12//:bytes",
+        "@rules_rust_proto__futures__0_1_29//:futures",
+        "@rules_rust_proto__iovec__0_1_4//:iovec",
+        "@rules_rust_proto__libc__0_2_69//:libc",
+        "@rules_rust_proto__log__0_4_6//:log",
+        "@rules_rust_proto__mio__0_6_21//:mio",
+        "@rules_rust_proto__mio_uds__0_6_7//:mio_uds",
+        "@rules_rust_proto__tokio_codec__0_1_2//:tokio_codec",
+        "@rules_rust_proto__tokio_io__0_1_13//:tokio_io",
+        "@rules_rust_proto__tokio_reactor__0_1_12//:tokio_reactor",
+    ],
+)
+
+# Unsupported target "datagram" with type "test" omitted
+
+# Unsupported target "stream" with type "test" omitted
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.unix_socket-0.5.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.unix_socket-0.5.0.bazel
new file mode 100644
index 0000000..c80941f
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.unix_socket-0.5.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "unix_socket",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.5.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__cfg_if__0_1_10//:cfg_if",
+        "@rules_rust_proto__libc__0_2_69//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.void-1.0.2.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.void-1.0.2.bazel
new file mode 100644
index 0000000..c228271
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.void-1.0.2.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "void",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.2.8.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.2.8.bazel
new file mode 100644
index 0000000..dc11f66
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.2.8.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "winapi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.3.8.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.3.8.bazel
new file mode 100644
index 0000000..a1bbaa2
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-0.3.8.bazel
@@ -0,0 +1,66 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "errhandlingapi",
+        "handleapi",
+        "minwindef",
+        "ntstatus",
+        "winbase",
+        "winerror",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.winapi-build-0.1.1.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-build-0.1.1.bazel
new file mode 100644
index 0000000..89fe026
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-build-0.1.1.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+alias(
+    name = "winapi_build",
+    actual = ":build",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+rust_library(
+    name = "build",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..fd204c2
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..b02d82a
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/proto/raze/remote/BUILD.ws2_32-sys-0.2.1.bazel b/third_party/rules_rust/proto/raze/remote/BUILD.ws2_32-sys-0.2.1.bazel
new file mode 100644
index 0000000..382300d
--- /dev/null
+++ b/third_party/rules_rust/proto/raze/remote/BUILD.ws2_32-sys-0.2.1.bazel
@@ -0,0 +1,65 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//proto/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+alias(
+    name = "ws2_32_sys",
+    actual = ":ws2_32",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+rust_library(
+    name = "ws2_32",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_proto__winapi__0_2_8//:winapi",
+    ],
+)
diff --git a/third_party/rules_rust/proto/repositories.bzl b/third_party/rules_rust/proto/repositories.bzl
new file mode 100644
index 0000000..af23033
--- /dev/null
+++ b/third_party/rules_rust/proto/repositories.bzl
@@ -0,0 +1,59 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//proto/raze:crates.bzl", "rules_rust_proto_fetch_remote_crates")
+
+# buildifier: disable=unnamed-macro
+def rust_proto_repositories(register_default_toolchain = True):
+    """Declare dependencies needed for proto compilation.
+
+    Args:
+        register_default_toolchain (bool, optional): If True, the default [rust_proto_toolchain](#rust_proto_toolchain)
+            (`@rules_rust//proto:default-proto-toolchain`) is registered. This toolchain requires a set of dependencies
+            that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.
+    """
+    maybe(
+        http_archive,
+        name = "rules_proto",
+        sha256 = "66bfdf8782796239d3875d37e7de19b1d94301e8972b3cbd2446b332429b4df1",
+        strip_prefix = "rules_proto-4.0.0",
+        urls = [
+            "https://mirror.bazel.build/github.com/bazelbuild/rules_proto/archive/refs/tags/4.0.0.tar.gz",
+            "https://github.com/bazelbuild/rules_proto/archive/refs/tags/4.0.0.tar.gz",
+        ],
+    )
+
+    maybe(
+        http_archive,
+        name = "com_google_protobuf",
+        sha256 = "758249b537abba2f21ebc2d02555bf080917f0f2f88f4cbe2903e0e28c4187ed",
+        strip_prefix = "protobuf-3.10.0",
+        urls = [
+            "https://mirror.bazel.build/github.com/protocolbuffers/protobuf/archive/v3.10.0.tar.gz",
+            "https://github.com/protocolbuffers/protobuf/archive/v3.10.0.tar.gz",
+        ],
+        patch_args = ["-p1"],
+        patches = [
+            Label("//proto/patches:com_google_protobuf-v3.10.0-bzl_visibility.patch"),
+        ],
+    )
+
+    rules_rust_proto_fetch_remote_crates()
+
+    # Register toolchains
+    if register_default_toolchain:
+        native.register_toolchains(str(Label("//proto:default-proto-toolchain")))
diff --git a/third_party/rules_rust/proto/toolchain.bzl b/third_party/rules_rust/proto/toolchain.bzl
new file mode 100644
index 0000000..5192436
--- /dev/null
+++ b/third_party/rules_rust/proto/toolchain.bzl
@@ -0,0 +1,217 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Toolchain for compiling rust stubs from protobuf and gRPC."""
+
+load("//rust:defs.bzl", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "name_to_crate_name")
+
+def generated_file_stem(file_path):
+    """Returns the basename of a file without any extensions.
+
+    Example:
+    ```python
+    content.append("pub mod %s;" % _generated_file_stem(f))
+    ```
+
+    Args:
+        file_path (string): A path to a file
+
+    Returns:
+        string: The file stem of the filename
+    """
+    basename = file_path.rsplit("/", 2)[-1]
+    basename = name_to_crate_name(basename)
+    return basename.rsplit(".", 2)[0]
+
+def rust_generate_proto(
+        ctx,
+        transitive_descriptor_sets,
+        protos,
+        imports,
+        output_dir,
+        proto_toolchain,
+        is_grpc = False):
+    """Generate a proto compilation action.
+
+    Args:
+        ctx (ctx): rule context.
+        transitive_descriptor_sets (depset): descriptor generated by previous protobuf libraries.
+        protos (list): list of paths of protos to compile.
+        imports (depset): directory, relative to the package, to output the list of stubs.
+        output_dir (str): The basename of the output directory for for the output generated stubs
+        proto_toolchain (ToolchainInfo): The toolchain for rust-proto compilation. See `rust_proto_toolchain`
+        is_grpc (bool, optional): generate gRPC stubs. Defaults to False.
+
+    Returns:
+        list: the list of generate stubs (File)
+    """
+
+    tools = [
+        proto_toolchain.protoc,
+        proto_toolchain.proto_plugin,
+    ]
+    executable = proto_toolchain.protoc
+    args = ctx.actions.args()
+
+    if not protos:
+        fail("Protobuf compilation requested without inputs!")
+    paths = ["%s/%s" % (output_dir, generated_file_stem(i)) for i in protos.to_list()]
+    outs = [ctx.actions.declare_file(path + ".rs") for path in paths]
+    output_directory = outs[0].dirname
+
+    if is_grpc:
+        # Add grpc stubs to the list of outputs
+        grpc_files = [ctx.actions.declare_file(path + "_grpc.rs") for path in paths]
+        outs.extend(grpc_files)
+
+        # gRPC stubs is generated only if a service is defined in the proto,
+        # so we create an empty grpc module in the other case.
+        tools.append(proto_toolchain.grpc_plugin)
+        tools.append(ctx.executable._optional_output_wrapper)
+        args.add_all([f.path for f in grpc_files])
+        args.add_all([
+            "--",
+            proto_toolchain.protoc.path,
+            "--plugin=protoc-gen-grpc-rust=" + proto_toolchain.grpc_plugin.path,
+            "--grpc-rust_out=" + output_directory,
+        ])
+        executable = ctx.executable._optional_output_wrapper
+
+    args.add_all([
+        "--plugin=protoc-gen-rust=" + proto_toolchain.proto_plugin.path,
+        "--rust_out=" + output_directory,
+    ])
+
+    args.add_joined(
+        transitive_descriptor_sets,
+        join_with = ":",
+        format_joined = "--descriptor_set_in=%s",
+    )
+
+    args.add_all(protos)
+    ctx.actions.run(
+        inputs = depset(
+            transitive = [
+                transitive_descriptor_sets,
+                imports,
+            ],
+        ),
+        outputs = outs,
+        tools = tools,
+        progress_message = "Generating Rust protobuf stubs",
+        mnemonic = "RustProtocGen",
+        executable = executable,
+        arguments = [args],
+    )
+    return outs
+
+def _rust_proto_toolchain_impl(ctx):
+    return platform_common.ToolchainInfo(
+        edition = ctx.attr.edition,
+        grpc_compile_deps = ctx.attr.grpc_compile_deps,
+        grpc_plugin = ctx.file.grpc_plugin,
+        proto_compile_deps = ctx.attr.proto_compile_deps,
+        proto_plugin = ctx.file.proto_plugin,
+        protoc = ctx.executable.protoc,
+    )
+
+# Default dependencies needed to compile protobuf stubs.
+PROTO_COMPILE_DEPS = [
+    Label("//proto/raze:protobuf"),
+]
+
+# Default dependencies needed to compile gRPC stubs.
+GRPC_COMPILE_DEPS = PROTO_COMPILE_DEPS + [
+    Label("//proto/raze:grpc"),
+    Label("//proto/raze:tls_api"),
+    Label("//proto/raze:tls_api_stub"),
+]
+
+rust_proto_toolchain = rule(
+    implementation = _rust_proto_toolchain_impl,
+    attrs = {
+        "edition": attr.string(
+            doc = "The edition used by the generated rust source.",
+            default = rust_common.default_edition,
+        ),
+        "grpc_compile_deps": attr.label_list(
+            doc = "The crates the generated grpc libraries depends on.",
+            cfg = "target",
+            default = GRPC_COMPILE_DEPS,
+        ),
+        "grpc_plugin": attr.label(
+            doc = "The location of the Rust protobuf compiler plugin to generate rust gRPC stubs.",
+            allow_single_file = True,
+            cfg = "exec",
+            default = Label("//proto:protoc_gen_rust_grpc"),
+        ),
+        "proto_compile_deps": attr.label_list(
+            doc = "The crates the generated protobuf libraries depends on.",
+            cfg = "target",
+            default = PROTO_COMPILE_DEPS,
+        ),
+        "proto_plugin": attr.label(
+            doc = "The location of the Rust protobuf compiler plugin used to generate rust sources.",
+            allow_single_file = True,
+            cfg = "exec",
+            default = Label("//proto:protoc_gen_rust"),
+        ),
+        "protoc": attr.label(
+            doc = "The location of the `protoc` binary. It should be an executable target.",
+            executable = True,
+            cfg = "exec",
+            default = Label("@com_google_protobuf//:protoc"),
+        ),
+    },
+    doc = """\
+Declares a Rust Proto toolchain for use.
+
+This is used to configure proto compilation and can be used to set different \
+protobuf compiler plugin.
+
+Example:
+
+Suppose a new nicer gRPC plugin has came out. The new plugin can be \
+used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//proto:toolchain.bzl', 'rust_proto_toolchain')
+
+rust_proto_toolchain(
+   name="rust_proto_impl",
+   grpc_plugin="@rust_grpc//:grpc_plugin",
+   grpc_compile_deps=["@rust_grpc//:grpc_deps"],
+)
+
+toolchain(
+    name="rust_proto",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_proto_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to register_toolchains in the WORKSPACE, or pass \
+it to the `--extra_toolchains` flag for Bazel, and it will be used.
+
+See @rules_rust//proto:BUILD for examples of defining the toolchain.
+""",
+)
diff --git a/third_party/rules_rust/proto/transitive_repositories.bzl b/third_party/rules_rust/proto/transitive_repositories.bzl
new file mode 100644
index 0000000..cd4a98c
--- /dev/null
+++ b/third_party/rules_rust/proto/transitive_repositories.bzl
@@ -0,0 +1,15 @@
+"""Definitions for loading transitive `@rules_rust//proto` dependencies"""
+
+load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
+load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies", "rules_proto_toolchains")
+
+def rust_proto_transitive_repositories():
+    """Load transitive dependencies of the `@rules_rust//proto` rules.
+
+    This macro should be called immediately after the `rust_proto_repositories` macro.
+    """
+    rules_proto_dependencies()
+
+    rules_proto_toolchains()
+
+    protobuf_deps()
diff --git a/third_party/rules_rust/rust/BUILD.bazel b/third_party/rules_rust/rust/BUILD.bazel
new file mode 100644
index 0000000..6fd4ced
--- /dev/null
+++ b/third_party/rules_rust/rust/BUILD.bazel
@@ -0,0 +1,30 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "known_shas.bzl",
+    "repositories.bzl",
+    "defs.bzl",
+    "toolchain.bzl",
+])
+
+toolchain_type(
+    name = "toolchain",
+)
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+    deps = [
+        "//rust/platform:bzl_lib",
+        "//rust/private:bzl_lib",
+        "//rust/settings:bzl_lib",
+    ],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//rust:bzl_lib` target instead",
+)
diff --git a/third_party/rules_rust/rust/defs.bzl b/third_party/rules_rust/rust/defs.bzl
new file mode 100644
index 0000000..dd1b445
--- /dev/null
+++ b/third_party/rules_rust/rust/defs.bzl
@@ -0,0 +1,124 @@
+# Copyright 2021 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Public entry point to all Rust rules and supported APIs."""
+
+load(
+    "//rust:toolchain.bzl",
+    _rust_stdlib_filegroup = "rust_stdlib_filegroup",
+)
+load(
+    "//rust/private:clippy.bzl",
+    _capture_clippy_output = "capture_clippy_output",
+    _rust_clippy = "rust_clippy",
+    _rust_clippy_aspect = "rust_clippy_aspect",
+)
+load("//rust/private:common.bzl", _rust_common = "rust_common")
+load(
+    "//rust/private:rust.bzl",
+    _rust_binary = "rust_binary",
+    _rust_library = "rust_library",
+    _rust_proc_macro = "rust_proc_macro",
+    _rust_shared_library = "rust_shared_library",
+    _rust_static_library = "rust_static_library",
+    _rust_test = "rust_test",
+    _rust_test_suite = "rust_test_suite",
+)
+load(
+    "//rust/private:rust_analyzer.bzl",
+    _rust_analyzer = "rust_analyzer",
+    _rust_analyzer_aspect = "rust_analyzer_aspect",
+)
+load(
+    "//rust/private:rustc.bzl",
+    _error_format = "error_format",
+    _extra_exec_rustc_flags = "extra_exec_rustc_flags",
+    _extra_rustc_flags = "extra_rustc_flags",
+)
+load(
+    "//rust/private:rustdoc.bzl",
+    _rust_doc = "rust_doc",
+)
+load(
+    "//rust/private:rustdoc_test.bzl",
+    _rust_doc_test = "rust_doc_test",
+)
+load(
+    "//rust/private:rustfmt.bzl",
+    _rustfmt_aspect = "rustfmt_aspect",
+    _rustfmt_test = "rustfmt_test",
+)
+
+rust_library = _rust_library
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_static_library = _rust_static_library
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_shared_library = _rust_shared_library
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_proc_macro = _rust_proc_macro
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_binary = _rust_binary
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_test = _rust_test
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_test_suite = _rust_test_suite
+# See @rules_rust//rust/private:rust.bzl for a complete description.
+
+rust_doc = _rust_doc
+# See @rules_rust//rust/private:rustdoc.bzl for a complete description.
+
+rust_doc_test = _rust_doc_test
+# See @rules_rust//rust/private:rustdoc_test.bzl for a complete description.
+
+rust_clippy_aspect = _rust_clippy_aspect
+# See @rules_rust//rust/private:clippy.bzl for a complete description.
+
+rust_clippy = _rust_clippy
+# See @rules_rust//rust/private:clippy.bzl for a complete description.
+
+capture_clippy_output = _capture_clippy_output
+# See @rules_rust//rust/private:clippy.bzl for a complete description.
+
+error_format = _error_format
+# See @rules_rust//rust/private:rustc.bzl for a complete description.
+
+extra_rustc_flags = _extra_rustc_flags
+# See @rules_rust//rust/private:rustc.bzl for a complete description.
+
+extra_exec_rustc_flags = _extra_exec_rustc_flags
+# See @rules_rust//rust/private:rustc.bzl for a complete description.
+
+rust_common = _rust_common
+# See @rules_rust//rust/private:common.bzl for a complete description.
+
+rust_analyzer_aspect = _rust_analyzer_aspect
+# See @rules_rust//rust/private:rust_analyzer.bzl for a complete description.
+
+rust_analyzer = _rust_analyzer
+# See @rules_rust//rust/private:rust_analyzer.bzl for a complete description.
+
+rustfmt_aspect = _rustfmt_aspect
+# See @rules_rust//rust/private:rustfmt.bzl for a complete description.
+
+rustfmt_test = _rustfmt_test
+# See @rules_rust//rust/private:rustfmt.bzl for a complete description.
+
+rust_stdlib_filegroup = _rust_stdlib_filegroup
+# See @rules_rust//rust:toolchain.bzl for a complete description.
diff --git a/third_party/rules_rust/rust/known_shas.bzl b/third_party/rules_rust/rust/known_shas.bzl
new file mode 100644
index 0000000..a4b5762
--- /dev/null
+++ b/third_party/rules_rust/rust/known_shas.bzl
@@ -0,0 +1,2470 @@
+"""A module containing a mapping of Rust tools to checksums
+
+This is a generated file -- see //util:fetch_shas
+"""
+
+FILE_KEY_TO_SHA = {
+    "2018-10-30/cargo-beta-aarch64-unknown-linux-gnu": "9d91fb3ee868421fbf8f4ed62cb7ee843dc6a1e70241331a9441e3ff09f3296d",
+    "2018-10-30/cargo-beta-x86_64-apple-darwin": "920d7218ded8ebd69628f7a7a1043117bec1ed6574ea8babbda66ddb7d0ea5f8",
+    "2018-10-30/cargo-beta-x86_64-pc-windows-msvc": "4f76c6264d36f1b0e9e23548d069386ff1b60a85a412596fc122484a4ed942fc",
+    "2018-10-30/cargo-beta-x86_64-unknown-freebsd": "be7ac5c344ca6038a7bcfbeb20c5847ce910ec39cf9a63b8b3e07cb6105dabb2",
+    "2018-10-30/cargo-beta-x86_64-unknown-linux-gnu": "097711a227d157c12a322dbe57f75eb28c7934869ce8aecc48d9946706234994",
+    "2018-10-30/clippy-beta-x86_64-apple-darwin": "84331ae735c78cd1d335b8b5da3c9232d70123197c62f3d7fe32b3bd7a97d1e6",
+    "2018-10-30/clippy-beta-x86_64-pc-windows-msvc": "a59573b3b71c318a75214876c30de03327c4b0409a2e9fa0127ef0ac4eab555d",
+    "2018-10-30/clippy-beta-x86_64-unknown-freebsd": "1fcc9d117d5721f3f4c6afb109c626fec238376666f448f61ed5aeaaa6c5a1d8",
+    "2018-10-30/clippy-beta-x86_64-unknown-linux-gnu": "eee913773c93ec0443aea1629d936b5a4e114e977318d4ef77b6bedf42cd4129",
+    "2018-10-30/llvm-tools-beta-aarch64-unknown-linux-gnu": "9417a07c501e173fe3848c815b8536cf70c6518c8040d45b19260ca3ab720760",
+    "2018-10-30/llvm-tools-beta-x86_64-apple-darwin": "b86d22bc723936f23186acaa94cd0738ff1c7b703d67712be62d99845a6ccc80",
+    "2018-10-30/llvm-tools-beta-x86_64-pc-windows-msvc": "cf74e15df51033370d4225fd9141f4cfc5c37145070d2296915fbecab9275b03",
+    "2018-10-30/llvm-tools-beta-x86_64-unknown-freebsd": "38ba85ec56c374b606a586221185ac351d04871892055f8936f28958e5e7a5cb",
+    "2018-10-30/llvm-tools-beta-x86_64-unknown-linux-gnu": "8d96f1475fc27f21d80bda80496783aa3181a4b33a138b7a89edcef2ddb6cf58",
+    "2018-10-30/rust-beta-aarch64-unknown-linux-gnu": "e9bc9d4a89299595ef42cde7303b50a7921e20a5ee4d131c4e1770a391611303",
+    "2018-10-30/rust-beta-x86_64-apple-darwin": "51acc0077d6abae5beed0e7b99c39ae9b8a0ff0f66daec227caef653046144e6",
+    "2018-10-30/rust-beta-x86_64-pc-windows-msvc": "07f3e42ba299b3b5341b410c4317161eba4b40bbc9fc449a9c187193fe49250c",
+    "2018-10-30/rust-beta-x86_64-unknown-freebsd": "49f1efe5bf10319446a298096dea73e478a466daca20a5b93d5263925e4ba9be",
+    "2018-10-30/rust-beta-x86_64-unknown-linux-gnu": "07963c2d6d56d077856f17e786414cf965832e7942f4ec72dec2eb51452e74b7",
+    "2018-10-30/rust-std-beta-aarch64-unknown-linux-gnu": "bf0895ccf65a86c1f51dbbebd0980bd07dcdc3919407fc84f5838cbbcb29e309",
+    "2018-10-30/rust-std-beta-aarch64-unknown-linux-musl": "53c07a1bdae00c0ad587349006e4080c50d511c0368f848fc98bf678dd3f6470",
+    "2018-10-30/rust-std-beta-wasm32-unknown-unknown": "5453e05993aaa90c8ac361086dd888a29a48f1b90b2c2184202c4b44b2e5569d",
+    "2018-10-30/rust-std-beta-x86_64-apple-darwin": "96fc1daea8868e176a14706333590b13a41193bd8ed5a711f23a15eceb5c6ce0",
+    "2018-10-30/rust-std-beta-x86_64-pc-windows-msvc": "6af758524d77288cb5c548d26467680d57aeb778063787662b1e00ef3887866a",
+    "2018-10-30/rust-std-beta-x86_64-unknown-freebsd": "5aef62464a5580ab6b38c9e54203db12f90ad42de538b7a5eefc7778b55b6497",
+    "2018-10-30/rust-std-beta-x86_64-unknown-linux-gnu": "34996a688d6a4c3587f873b0a8c86fe1d2fee2a269b6e669b1cb8c6908fb77b8",
+    "2018-10-30/rust-std-beta-x86_64-unknown-linux-musl": "6e9474546838c061288e8464d28a843814bc2ff4c9d06a5fba065c1b03650be4",
+    "2018-10-30/rustc-beta-aarch64-unknown-linux-gnu": "e6bb89261baa494ef98239bde9821b66671de5cd78352a9c100abce3a18ca250",
+    "2018-10-30/rustc-beta-x86_64-apple-darwin": "22153f359b8b98341aa0349233112fff2b9f092988f9d678626207ba29666b5b",
+    "2018-10-30/rustc-beta-x86_64-pc-windows-msvc": "9cd8225f1307aab95b439dbecd70aaa35e03c913ba0897dc7fe3a04755fc15b1",
+    "2018-10-30/rustc-beta-x86_64-unknown-freebsd": "e207562cd5e3a17497e029bcb1cab56d9fa474d788906f13e389a3cb804ea4d6",
+    "2018-10-30/rustc-beta-x86_64-unknown-linux-gnu": "63b69b000cda551f2499ffba6e3f1700acb2b22a47ca9ec9edcc3e578ed086e6",
+    "2018-10-30/rustfmt-beta-aarch64-unknown-linux-gnu": "bd97e8012277d49beececdf4125610c2d0112cd22f8add53f86fd7c6dac5dc0d",
+    "2018-10-30/rustfmt-beta-x86_64-apple-darwin": "2c213f43902104ebefe9eee6fa49aa36e16af972cb7aa1c63d772e5d05f74b59",
+    "2018-10-30/rustfmt-beta-x86_64-pc-windows-msvc": "316331e7aed82251ab3b701845e8b1e707947670498ce4fc364ce1d6813e1340",
+    "2018-10-30/rustfmt-beta-x86_64-unknown-freebsd": "17826e710d5912d23cd981b46b598733cf8833c20dc7d03d150c5e53ad0a38d3",
+    "2018-10-30/rustfmt-beta-x86_64-unknown-linux-gnu": "4af3f9faacd78deef2e8a06e2971ebc7540de07525ac805fcf334818a6ee0e97",
+    "2018-11-01/cargo-beta-aarch64-unknown-linux-gnu": "44802e459a0bc1677b52593d413959982c30786524412e9e1c61d67c8230d4f6",
+    "2018-11-01/cargo-beta-x86_64-apple-darwin": "e5130c79154056a451d95a3b213622d0e7e3dd3625735fa5ae725fa50849facb",
+    "2018-11-01/cargo-beta-x86_64-pc-windows-msvc": "481f845f171e4566c59d9a2df802c678b6102d2d661b731e2a71a50c597cbeca",
+    "2018-11-01/cargo-beta-x86_64-unknown-freebsd": "0b596632c675a277fac894b644ecdb86d6f44036dd089ce8d410fdd04354b8f1",
+    "2018-11-01/cargo-beta-x86_64-unknown-linux-gnu": "8519d3fca6aca45ed94daeecbd8d25c9bd1c75f1acc5078b64b771bce6986b44",
+    "2018-11-01/clippy-beta-x86_64-apple-darwin": "8672df2c6b8a18bbf9b654188de22bc8ce4c8bc407d2b3fe3ef208add4e27cdd",
+    "2018-11-01/clippy-beta-x86_64-pc-windows-msvc": "4cea4a9cbbc0b56efe11078711d244ab87de3397873c437f3f70614ef896ff83",
+    "2018-11-01/clippy-beta-x86_64-unknown-freebsd": "03fabba8670a06faeee0a944ca8e911e717a739c2bae0262c2257db69a7014f5",
+    "2018-11-01/clippy-beta-x86_64-unknown-linux-gnu": "0ad5f06495177901addb72d8eec3926986e10290969493eba0e8b465962985e7",
+    "2018-11-01/llvm-tools-beta-aarch64-unknown-linux-gnu": "7b3f5bb7f45052310efe275ed665b54b55e19b9020b04cec9240318c13c62c0d",
+    "2018-11-01/llvm-tools-beta-x86_64-apple-darwin": "b45ae0fb0b49385b555772a3faa9a5a85aa10f4bd24ba40c55048076d8cda314",
+    "2018-11-01/llvm-tools-beta-x86_64-pc-windows-msvc": "462668f55b85fa1224df30449eb67e8fe0d208caeea39d9339b44ac30867f452",
+    "2018-11-01/llvm-tools-beta-x86_64-unknown-freebsd": "acd86ceedad9f10b2cb3443df032d0b5a9b4eb6c4b30364bd3cb014449607577",
+    "2018-11-01/llvm-tools-beta-x86_64-unknown-linux-gnu": "4b4363c2d03d319e84a7f09fba5b58d188d9fdd62c9486cc4b66e9e63030ab27",
+    "2018-11-01/rust-beta-aarch64-unknown-linux-gnu": "f802784788c2e751d59d035363fb6be2b0450d650ec523115a51fea05fc8589b",
+    "2018-11-01/rust-beta-x86_64-apple-darwin": "0be8d634d17b2f92c86515a38e36f66a9f3d72bad226db58ff8cd09924092f53",
+    "2018-11-01/rust-beta-x86_64-pc-windows-msvc": "d86d633b67e6c0fba28963f5c991738575fee56c755570e505f702eed54150e9",
+    "2018-11-01/rust-beta-x86_64-unknown-freebsd": "869f1d01077a318ff0ac664a498354b079c2fc16cbec294161a56cabe6f3e194",
+    "2018-11-01/rust-beta-x86_64-unknown-linux-gnu": "7da7bd24c2f2dafa9d4baa6e7eba1547f62681fbd1dd89910d386b2260e65ca6",
+    "2018-11-01/rust-std-beta-aarch64-unknown-linux-gnu": "137d39872981d343829a8f3eecf0f33fe2f0d81ed18865004b52359d309a6b95",
+    "2018-11-01/rust-std-beta-aarch64-unknown-linux-musl": "5eb228ae2a53abfdfbfaa471a2afda29cc2b923adb82322a0c20af4592c226e5",
+    "2018-11-01/rust-std-beta-wasm32-unknown-unknown": "4f7fa7f3adafc2ec5de80cddfd3fc3072da43442cd15be9169b261f76a0a684b",
+    "2018-11-01/rust-std-beta-x86_64-apple-darwin": "bee742244d72ea7289d5d2dea519102994dbee97a5c296b2a8c6853e5450a7ab",
+    "2018-11-01/rust-std-beta-x86_64-pc-windows-msvc": "455ecff7f11499cd3822b82ecf0ab8ab34d866c4b5e17b0de84af815a782f226",
+    "2018-11-01/rust-std-beta-x86_64-unknown-freebsd": "eed13a5c36c0731b01b8926f26be5b054c341a0487628fca688e8e99f33b200b",
+    "2018-11-01/rust-std-beta-x86_64-unknown-linux-gnu": "f38a224bccfc89bd0d598764363271985d0b2696123ea10de6399c4cc7dd8adb",
+    "2018-11-01/rust-std-beta-x86_64-unknown-linux-musl": "b4f8c208a50e2640fc3761675bef31c9960e74976a1537c2fd8c9dc8a9d5fdd8",
+    "2018-11-01/rustc-beta-aarch64-unknown-linux-gnu": "acf359a4cecfc827f5ca4255c0492d46223d09d535444f0b303678918944c87c",
+    "2018-11-01/rustc-beta-x86_64-apple-darwin": "64b5a5fc8b3dc348395137df2c422adbf483168c58af5cd9acc8522dd9b4392b",
+    "2018-11-01/rustc-beta-x86_64-pc-windows-msvc": "71cbfd2793f6b55653f5ef4bdf0350dfe6d9b0952d518a3a355044ec7caa03c2",
+    "2018-11-01/rustc-beta-x86_64-unknown-freebsd": "51a5370f1776229bede506e5ab05da7cfeb5bd21a5374561acb4b7138c75d508",
+    "2018-11-01/rustc-beta-x86_64-unknown-linux-gnu": "01609bedca249906ba8e07fb681daffe094cdbf41b91e2221195474271d8e6d7",
+    "2018-11-01/rustfmt-beta-aarch64-unknown-linux-gnu": "0969e37628a3d5e56cfc0636db4d1aac7d0b01ab9df6bdeb3453adc1e2ae786e",
+    "2018-11-01/rustfmt-beta-x86_64-apple-darwin": "bbb45d6beddf8da270ab1ec6ea3b9dc2ffc03f5ba1ef3e99e87d004f652f2581",
+    "2018-11-01/rustfmt-beta-x86_64-pc-windows-msvc": "2d34424353e248173828898107e331acfbaa29a3686bb8121fdc72fbab7a37e8",
+    "2018-11-01/rustfmt-beta-x86_64-unknown-freebsd": "101a0903c5421df363420d73ebbdb52b3cb8b2bb5ecee9e383b271aa22446f95",
+    "2018-11-01/rustfmt-beta-x86_64-unknown-linux-gnu": "12d49bf16a8e5964163d12a58e8caa5bf81fedd106dc37bbd757aa4116f0d7b3",
+    "2018-11-02/cargo-beta-aarch64-unknown-linux-gnu": "808e7129f0f414e05def68ac72bb8f59871a0d21eaa9a6b9a59afa87502858bc",
+    "2018-11-02/cargo-beta-x86_64-apple-darwin": "72fce301579b799b392407c49e162285ba24ca17ad1d96ca701c7d03c83d69d0",
+    "2018-11-02/cargo-beta-x86_64-pc-windows-msvc": "f2a98c4c8928d7d3070c86c02ab93e6d78c85312e1eee2867efabf00ae235692",
+    "2018-11-02/cargo-beta-x86_64-unknown-freebsd": "8069c2b1657b3dc747912775b1569426bccf35fe6c23073408847ef232174419",
+    "2018-11-02/cargo-beta-x86_64-unknown-linux-gnu": "2e9418c06ea6dc3f869ebd12e31da2affe9568871e65f013b3695a92bdfa4c31",
+    "2018-11-02/clippy-beta-x86_64-apple-darwin": "921f5d07e73a5651173187012c476a7999f5cd78f52eafad4e8c15f2bab25b42",
+    "2018-11-02/clippy-beta-x86_64-pc-windows-msvc": "eee0ff30ede35ab957061b579836de5f9b91c36d57e71c22344c76d421abd4dc",
+    "2018-11-02/clippy-beta-x86_64-unknown-freebsd": "440576edb7ac7775d5511780662b8c820da8cfdcf71dfe7a169758547d5f94e4",
+    "2018-11-02/clippy-beta-x86_64-unknown-linux-gnu": "3ce406e0c2bb246c96940e4054b5fa9b049580ae4b61e170da2008ff945af970",
+    "2018-11-02/llvm-tools-beta-aarch64-unknown-linux-gnu": "f8021a8a0d302eb4774d31789932488e0897ec72b0d8c16cb746a2d72b749238",
+    "2018-11-02/llvm-tools-beta-x86_64-apple-darwin": "88693cabad55f568ca0c21276e76eb237215abdc9771f224ab807f8edd3aad08",
+    "2018-11-02/llvm-tools-beta-x86_64-pc-windows-msvc": "4b2f2c707bbd3506c55d48d1ff3cadd290445b227c868d596a535faa798f06cf",
+    "2018-11-02/llvm-tools-beta-x86_64-unknown-freebsd": "c8c48f8805b794ac63cbd60bb28d77c575d754c6c97af006bcf6b466adb5ecab",
+    "2018-11-02/llvm-tools-beta-x86_64-unknown-linux-gnu": "92472b453b0a6dbc38cef53cba6d38b5dbc79e3637743b77239543b33084d121",
+    "2018-11-02/rust-beta-aarch64-unknown-linux-gnu": "6e28b053d8ebcef7a19875089db13931ce89bb045d06b4bf834334df3fa43962",
+    "2018-11-02/rust-beta-x86_64-apple-darwin": "78e9fd57d2070cbe2a073758839d54b5535e14918c11260fb244bade3c1971a3",
+    "2018-11-02/rust-beta-x86_64-pc-windows-msvc": "68c0fcbd1f9887eff41c42b703fb2c34b99b2490f4e366efeee4a6bf0c1044c2",
+    "2018-11-02/rust-beta-x86_64-unknown-freebsd": "8313e8655fca87519c469c5699cf803fb0c1bd159ee335aac199ae76753f359d",
+    "2018-11-02/rust-beta-x86_64-unknown-linux-gnu": "76b2d14dc01a922b448019df7a24221f91c7eaa3e2034fcbd6189d5bac7836e4",
+    "2018-11-02/rust-std-beta-aarch64-unknown-linux-gnu": "0d57f4837af1443208abce604d74dcf6880d0cdf4e74eaf2368016f064dbc7ab",
+    "2018-11-02/rust-std-beta-aarch64-unknown-linux-musl": "0d5e585506b4cde724040d340e8e2d4a3ebe04950ca863adb238c83f9462e696",
+    "2018-11-02/rust-std-beta-wasm32-unknown-unknown": "25c7e8dbf27dd19d3d4f91062d9cb9bc6ad9aed8afacbd47dab92eba3a3d2533",
+    "2018-11-02/rust-std-beta-x86_64-apple-darwin": "fdc26de5db0e66e0f516069690a0c86ca0e4b8b75973a33dee67ce306e4c9115",
+    "2018-11-02/rust-std-beta-x86_64-pc-windows-msvc": "8c7dfe0692e2c0b9de130b64e8ab09946eff2eb419a22bb7a15cd9522995f420",
+    "2018-11-02/rust-std-beta-x86_64-unknown-freebsd": "4661fdd15b5cee0fafd4c9cb085d0614abab0b2b1d62a55540b3d4d2634c4ba7",
+    "2018-11-02/rust-std-beta-x86_64-unknown-linux-gnu": "3e2f68697620e501a9439bb7923f5676c82f7a4b4aaf822a141188c92619fe13",
+    "2018-11-02/rust-std-beta-x86_64-unknown-linux-musl": "88662ac89a6c9df7a5a77db8624777cb9ccf0ecdd9a0ced1ef9bc47e7c9e8eed",
+    "2018-11-02/rustc-beta-aarch64-unknown-linux-gnu": "d703f1cdecd77aba85024db5e94f13e50c74e66af21091107c7cd67a3179da15",
+    "2018-11-02/rustc-beta-x86_64-apple-darwin": "199a0776ad4f1406b8b6f477d12c58858816f07246d52842384e1084d8c9000e",
+    "2018-11-02/rustc-beta-x86_64-pc-windows-msvc": "a4fd3838f4459a151e83d540784953cd80c5a1a68fe3bf965399c1f07f6476bb",
+    "2018-11-02/rustc-beta-x86_64-unknown-freebsd": "f931cb44b892dc3899c9379238d8f51d35c9503db9e93ce5700f3121712c9b62",
+    "2018-11-02/rustc-beta-x86_64-unknown-linux-gnu": "7ebd46c431b8d9e8d22aa141122eaf301d5facdc449e04872019372598b04b19",
+    "2018-11-02/rustfmt-beta-aarch64-unknown-linux-gnu": "c13f8024e37f7b2b6d97586569bdefca53e99514e4b76b200b71932f4a7ce298",
+    "2018-11-02/rustfmt-beta-x86_64-apple-darwin": "0164c2c57b3ee975c571103dbf7074e24c997cc43df23920660f12de688e8c23",
+    "2018-11-02/rustfmt-beta-x86_64-pc-windows-msvc": "c33b4fe885e21f51b08dfa29d04179d0f138e87122f4f4a3898fa002567f2259",
+    "2018-11-02/rustfmt-beta-x86_64-unknown-freebsd": "ad280d28d4e7054063942cd5a60cc35538af5096f29e159ba13419b82be5560c",
+    "2018-11-02/rustfmt-beta-x86_64-unknown-linux-gnu": "60ec376659a4ad5b129307ffef4dfe9b717fcee6f5d929b1e3e423e599258be2",
+    "2018-11-07/cargo-nightly-aarch64-unknown-linux-gnu": "45f1fe31b55aac2de8fa98c5738704481e27c3bf206ca7a65b165b301f473a1e",
+    "2018-11-07/cargo-nightly-x86_64-apple-darwin": "35ad1d24795b3fe97dc06fe3b1a45c2e75cc9e62bdf491d4964863920b311e0d",
+    "2018-11-07/cargo-nightly-x86_64-pc-windows-msvc": "7147bc0363fb84aa2feda337a6bf7e3f16f26aef893218cd0b59c31793c06253",
+    "2018-11-07/cargo-nightly-x86_64-unknown-freebsd": "d537821f8acf2a89d44bc534fbf5efc27785df372005046be927c0d1ae088a23",
+    "2018-11-07/cargo-nightly-x86_64-unknown-linux-gnu": "7968167992937ad8e7284c9ea00040ddd873b759b2595eb67eea68ce81abf627",
+    "2018-11-07/clippy-nightly-x86_64-apple-darwin": "7ee34bc4e2b1121ecb8ad01bbebc54f83bafd72acb8e4f81bb3cd1106fc29cdb",
+    "2018-11-07/clippy-nightly-x86_64-pc-windows-msvc": "a65fd2d2c7e53d3876808b41491d2556a55e399a470d747427f6ece40251ca89",
+    "2018-11-07/clippy-nightly-x86_64-unknown-freebsd": "664296ae2a0226abcb58d01067b3a614fa6c66afb821e36be17faa205ef14f70",
+    "2018-11-07/clippy-nightly-x86_64-unknown-linux-gnu": "62cf4c3f179e14b6b26485d85ebf17ff676b87938c14bb1ce19d93c02197d091",
+    "2018-11-07/llvm-tools-nightly-aarch64-unknown-linux-gnu": "c2dd30b73e5e0495d7d4c05cf98f50197c00f542cef7f3ef37e095d0d8686991",
+    "2018-11-07/llvm-tools-nightly-x86_64-apple-darwin": "2cd61d0f54d3753777b019d09a2e88cc9a2fb027e947a14eb1f509e014ff19e9",
+    "2018-11-07/llvm-tools-nightly-x86_64-pc-windows-msvc": "14c6387239ee0bd8d9d9ca0c21c808a542de4133e8477fc2f1fc958eaf6c4428",
+    "2018-11-07/llvm-tools-nightly-x86_64-unknown-freebsd": "52a726f57b80cc7d29c15b93ad35e3a7ab62fcfbd7d89f91021a783be6ffbd18",
+    "2018-11-07/llvm-tools-nightly-x86_64-unknown-linux-gnu": "ddd007ee68b7468a12d240d0f08939efa262e8d96ad7f903cbef62b461a61417",
+    "2018-11-07/rust-nightly-aarch64-unknown-linux-gnu": "f4725077e948b6eda7d4cd482a8985037a2f8ddaecc964908a490deb9ac46e21",
+    "2018-11-07/rust-nightly-x86_64-apple-darwin": "b9aaefca51aa2d7e89f5d790e865d00ec4142c79cebee43ba0d575f9f52ee65b",
+    "2018-11-07/rust-nightly-x86_64-pc-windows-msvc": "5826f958e4826b0bd0069918185afc6db0802e6d3fe72a9be075f3408b707521",
+    "2018-11-07/rust-nightly-x86_64-unknown-freebsd": "38860320b7e97193493e45d362f34d311d7aa8fface77c93fadfa15e8361df3d",
+    "2018-11-07/rust-nightly-x86_64-unknown-linux-gnu": "c1d7542e90f76d074a7ea925b5ce40ec602c9e3e04822939623a98c4d020ea2e",
+    "2018-11-07/rust-std-nightly-aarch64-unknown-linux-gnu": "e7a4629ab15609fda17a9e16cb0f7538d4077f572ece200891726344e314295b",
+    "2018-11-07/rust-std-nightly-aarch64-unknown-linux-musl": "25b7b0cef1f802182ffd26e62defbc5f6fc79504739d14627bc74ca1db24bdaf",
+    "2018-11-07/rust-std-nightly-wasm32-unknown-unknown": "9d1bcbf50fdcd9912fd98901ec40c7fd5d73ef2262a70322b4ca52381363c34c",
+    "2018-11-07/rust-std-nightly-x86_64-apple-darwin": "0c988a60e72d545b19b5cef616ddd3411a278226abccceca622581871f2b5cce",
+    "2018-11-07/rust-std-nightly-x86_64-pc-windows-msvc": "0d04200b3bc5ad5f939d98f7af083c0576aae11876830492f9964de23dd33acd",
+    "2018-11-07/rust-std-nightly-x86_64-unknown-freebsd": "ca648e7eb243cec32dc5a1b4e2fe6d67c2a00be56326e4d7aec9f2bbeb4dc138",
+    "2018-11-07/rust-std-nightly-x86_64-unknown-linux-gnu": "bd8daba5c2d36e261da6f0ea8b5893e7fe94252eca7478d581c036fc1acb7c36",
+    "2018-11-07/rust-std-nightly-x86_64-unknown-linux-musl": "9d5bb908baa470e4da390f5b32f7db2c15fdc347d379b61522a33128bb486b12",
+    "2018-11-07/rustc-nightly-aarch64-unknown-linux-gnu": "11caf45fef229d85efb36cdbcf955d95fae648c27ca4ffd153bad316eb58793a",
+    "2018-11-07/rustc-nightly-x86_64-apple-darwin": "cddecdb0d595cb8b944bf70b2284f557743f5637536f2181ad0036806cf56217",
+    "2018-11-07/rustc-nightly-x86_64-pc-windows-msvc": "479f58f34616b83c003fa29e68ee84c91ee5521038f255a7cd3b597a2f5082d0",
+    "2018-11-07/rustc-nightly-x86_64-unknown-freebsd": "47f81ec8c4ebbcd4e948033b5db72c1e9bec6f284fdaa5bdf59bcc92b075333f",
+    "2018-11-07/rustc-nightly-x86_64-unknown-linux-gnu": "7f1aa11f8e503e6e9a03b6cd05ab12b46837bb7597167c72112abaf1481e46cd",
+    "2018-11-07/rustfmt-nightly-aarch64-unknown-linux-gnu": "9b64705de20633c73a39d47deacbacdce11181dc5e06fa632ef08b8a3a7136e0",
+    "2018-11-07/rustfmt-nightly-x86_64-apple-darwin": "bb86c58a5a12922ddd2d19a3cffe9cd8d87785e57f72cdc998e94926a68345a2",
+    "2018-11-07/rustfmt-nightly-x86_64-pc-windows-msvc": "4612d2961bc5d0b24863af21fd0764b8ec8d2a843f1a39b97b418bc283b8fa2b",
+    "2018-11-07/rustfmt-nightly-x86_64-unknown-freebsd": "b0677e91bb7c0645844f988e7f7b625768f0a72947536a27fce7f5a9a850c5e0",
+    "2018-11-07/rustfmt-nightly-x86_64-unknown-linux-gnu": "e1dbad0cb0afccdf5e05f97129f9d34bc62ce6475dd8f09fad2d31a8129acf64",
+    "2018-11-08/cargo-nightly-aarch64-unknown-linux-gnu": "df9cf735f2c0efc48356832b0a11ae3f6df0d78879fb93a3b9cfecb15e79010b",
+    "2018-11-08/cargo-nightly-x86_64-apple-darwin": "e0a585f21907bd78820c4fd0ac56625ba10053a9430e9fab014e90e42f4a1fab",
+    "2018-11-08/cargo-nightly-x86_64-pc-windows-msvc": "025741e19216a317d8c2bb27950fbd7c3eef6eae075c606fc4b0622d3a92b89c",
+    "2018-11-08/cargo-nightly-x86_64-unknown-freebsd": "7e9343a3885caa12c1fb7f3007e8c72ce0a11ea6696839e0882ef7e560aed6d8",
+    "2018-11-08/cargo-nightly-x86_64-unknown-linux-gnu": "b421dd73cac889804f9d3758f5ef32157885a043abfb21651182fc9f672b7491",
+    "2018-11-08/clippy-nightly-x86_64-apple-darwin": "a1b8fa097c8814ea239bc78f13df97a39d7361516b68ef340d9e42d0ee2905e3",
+    "2018-11-08/clippy-nightly-x86_64-pc-windows-msvc": "f863e10d8b82428771ac10a3219094f4252239df68f611a4dfa075a836f6be75",
+    "2018-11-08/clippy-nightly-x86_64-unknown-freebsd": "87cc3be056acb88e08d2dffbe7924aea58e39bb7380cda44e23748f790f15e95",
+    "2018-11-08/clippy-nightly-x86_64-unknown-linux-gnu": "b1f0ca2c7f5367dc044a3ca1702618e0e58f777369d470a8173355e2f4507127",
+    "2018-11-08/llvm-tools-nightly-aarch64-unknown-linux-gnu": "fe2283cabacf6b8dbcd8d11eddb11a2badb750091ec5b38926ad48d3577da601",
+    "2018-11-08/llvm-tools-nightly-x86_64-apple-darwin": "b173d662715ec4edacdb8e06570cd471a6f63d05b49c6867f95ec366f8a2e0db",
+    "2018-11-08/llvm-tools-nightly-x86_64-pc-windows-msvc": "558cd81ceb5e08766ade45cffc98a8d1a179d34f671f9b9518627e8358d65984",
+    "2018-11-08/llvm-tools-nightly-x86_64-unknown-freebsd": "7d77f85900b0aa276df746bc023b1211c4221e6183ef62663565b65b8fadd9f8",
+    "2018-11-08/llvm-tools-nightly-x86_64-unknown-linux-gnu": "c634eb65a3839b176563823d576b1f4705cfcb3e91b237f2c4f852ff5ba08d2a",
+    "2018-11-08/rust-nightly-aarch64-unknown-linux-gnu": "20ef5c5f59171df0335846c6c3315c5e3c495775e3c5b1060481d70421153412",
+    "2018-11-08/rust-nightly-x86_64-apple-darwin": "921f19787a155e5240e21fb2bc630e5907b964652b0f7553b64acf819a0a2d43",
+    "2018-11-08/rust-nightly-x86_64-pc-windows-msvc": "46d76bb12cedd53927cb35fb688540010b5152568467508fa92b0745f0e39463",
+    "2018-11-08/rust-nightly-x86_64-unknown-freebsd": "32c28d8e915086406a3493d59d0e3b4c4751f77a3b34d257a3341aa4e5f8ad4f",
+    "2018-11-08/rust-nightly-x86_64-unknown-linux-gnu": "5f33f1c01720e471b8293d304a01f354363418dc7ceebf206529a34f932c3a82",
+    "2018-11-08/rust-std-nightly-aarch64-unknown-linux-gnu": "e83ecf484a848053a8679c8164340f90bd6c5823d9340b4fc5318c6265e544f1",
+    "2018-11-08/rust-std-nightly-aarch64-unknown-linux-musl": "89e192bc7e9fad3eea6e24f967b9405b35c677b1fe3a6b8fb4ab4def4f6378d9",
+    "2018-11-08/rust-std-nightly-wasm32-unknown-unknown": "0e12ecd9a2bbff67b8d82c15200acdd32d1f91fc1761d0b72fbbb5d32ae629f9",
+    "2018-11-08/rust-std-nightly-x86_64-apple-darwin": "9d5e89e71f888247093b5615079da538a56c2758eac270173a4f85a57ef92967",
+    "2018-11-08/rust-std-nightly-x86_64-pc-windows-msvc": "e891a3ee103e65e8e337b3c9c9d1e410c4be97b1318f820b591565b5ae6340ff",
+    "2018-11-08/rust-std-nightly-x86_64-unknown-freebsd": "64aabfec15a2b773c27892e58514161cb05ab370e3291beb1cafc7d270772389",
+    "2018-11-08/rust-std-nightly-x86_64-unknown-linux-gnu": "efb8f6f6aa2c5a3f1c069e05b74fde6a85985837054faf3bc565d839902efedc",
+    "2018-11-08/rust-std-nightly-x86_64-unknown-linux-musl": "d2629d2ae1dae0b80bff33350f1bd469e145bfc4b935ff4bcb79240ff23ab279",
+    "2018-11-08/rustc-nightly-aarch64-unknown-linux-gnu": "494173aa705efeef4df2d88278608bd71b477183d85a670a577051c76c5ee99c",
+    "2018-11-08/rustc-nightly-x86_64-apple-darwin": "316e7727a136a82a20832a69b18f74add335e9b659fa7e0d8c7d12c0d11224b7",
+    "2018-11-08/rustc-nightly-x86_64-pc-windows-msvc": "489cb54446374eccc78eca18aa86b4159d47fdfa7bab0ea9a20cb68fa4d80071",
+    "2018-11-08/rustc-nightly-x86_64-unknown-freebsd": "874b7055e0cb609ce34d38456bda888865c63fcbc7abac5aad147f2a21a7d147",
+    "2018-11-08/rustc-nightly-x86_64-unknown-linux-gnu": "e50e43d71573e069503aa6157d1736d390345006965fa889842835ce80ae36e2",
+    "2018-11-08/rustfmt-nightly-aarch64-unknown-linux-gnu": "4f5f4077d0e1c888fa3366dad638b5e8c7aa032deab83334a170d8e4275d8e47",
+    "2018-11-08/rustfmt-nightly-x86_64-apple-darwin": "b6a0f812726134aea52e2b6ad708c0fb1052f80f1515a66cddeeef07052a67cb",
+    "2018-11-08/rustfmt-nightly-x86_64-pc-windows-msvc": "eb444b276ae5f6ed2c1e6dce994e17ebb94b130747a05c402e0c96b2623a554d",
+    "2018-11-08/rustfmt-nightly-x86_64-unknown-freebsd": "8b31f7677eb0e7bf6ab145a6347e0ff00e57ec3642db3269763d97020cad2ebb",
+    "2018-11-08/rustfmt-nightly-x86_64-unknown-linux-gnu": "bf4c5913c199a5cfeea53432c880a02ba1ec6b38eaa59f012a909a131cf11cf6",
+    "2018-11-09/cargo-nightly-aarch64-unknown-linux-gnu": "e2db9ce2b561d7fdc456431b661be0b68e0a97b932096595fad273a9dfaa8b05",
+    "2018-11-09/cargo-nightly-x86_64-apple-darwin": "696507e163c5ea342a3780da51efd51633dcfcc980b493479928b9a3e0894157",
+    "2018-11-09/cargo-nightly-x86_64-pc-windows-msvc": "0537061725164e1c344b73ec85a1983966537e7f0d4c231233bd6aa6a30428e0",
+    "2018-11-09/cargo-nightly-x86_64-unknown-freebsd": "07935c23f2f71e30092672010975ed16d34a9f50a9ab4deb86c9846d79a4729a",
+    "2018-11-09/cargo-nightly-x86_64-unknown-linux-gnu": "0f5448e37227d79689967658252a43d48c596ee875fff5d7a530b20cfd408bdc",
+    "2018-11-09/clippy-nightly-x86_64-apple-darwin": "42ee57c56b42dd837b9aaa4307cb9f57421cb430264048de9b291733438f6f85",
+    "2018-11-09/clippy-nightly-x86_64-pc-windows-msvc": "83b0f6b8423dd3061d5d9956371e6665f13bd857e711226f9684e29b88294593",
+    "2018-11-09/clippy-nightly-x86_64-unknown-freebsd": "0dc28f63ceea25edefb7b96bf5c8bf746b68505307ebd9c38a8aa7b6d3d2059e",
+    "2018-11-09/clippy-nightly-x86_64-unknown-linux-gnu": "f56e10ae1c09b0356514fdb411a9b38597d824e080e7cb050588fd627c4a544a",
+    "2018-11-09/llvm-tools-nightly-aarch64-unknown-linux-gnu": "83188eccc2b7067dcfc960492f91d23ad36ea6460005ac6b91c98d20694e60a6",
+    "2018-11-09/llvm-tools-nightly-x86_64-apple-darwin": "03e2e4ba7ffabe88b118f1207b820cc6c7ab0d79d478c1687ec5bb1c903b4045",
+    "2018-11-09/llvm-tools-nightly-x86_64-pc-windows-msvc": "63a4f2c85f3ef51efb0075944ad0249337cdd7c9593036995f79699393a458d7",
+    "2018-11-09/llvm-tools-nightly-x86_64-unknown-freebsd": "f9ddf5f1e02b800aaa0add32365d62e5dcf590cc130af5b209cdf8520f9262a1",
+    "2018-11-09/llvm-tools-nightly-x86_64-unknown-linux-gnu": "8b3e2e2bf77224e181a9b1987bd2ae940a0462f8b0af84b59de484f8fe96ffb8",
+    "2018-11-09/rust-nightly-aarch64-unknown-linux-gnu": "4d0f22349061a40a834ae6a40640c0f4e8a19f068a215af0fb0b9a7250942d3f",
+    "2018-11-09/rust-nightly-x86_64-apple-darwin": "934b83bbfcbca605875103293cf691a56429661e929e1c29fec2d3c5c1d65143",
+    "2018-11-09/rust-nightly-x86_64-pc-windows-msvc": "6659d7b9001a3613ca6b2bb64e5f6bd67cae51bf02e81b8b96dfe2299a180a21",
+    "2018-11-09/rust-nightly-x86_64-unknown-freebsd": "b50b1cf51e8bd138d55dc77f681904e1b431e7c956951ec603a3d94ff81a0783",
+    "2018-11-09/rust-nightly-x86_64-unknown-linux-gnu": "163e0666f2f7179caa9c5baa8b0280c618dc163007a73f5da0a0c917bd2b8902",
+    "2018-11-09/rust-std-nightly-aarch64-unknown-linux-gnu": "cb12c26ec032ede34f925ea7c57118c8694dee439f0e258f8655b83e08512a43",
+    "2018-11-09/rust-std-nightly-aarch64-unknown-linux-musl": "5e0d20f6f2b01bb661724cb5478fddd37c560f2848af9961da44d0ae75029b1c",
+    "2018-11-09/rust-std-nightly-wasm32-unknown-unknown": "a0084c768151b5cb7554085b77fdbbc014a1ba246335623a36b58e7f6bb95fb0",
+    "2018-11-09/rust-std-nightly-x86_64-apple-darwin": "dbc9ffa483484380e41b6514465523f6ef106be5708374b714458d14f76149c4",
+    "2018-11-09/rust-std-nightly-x86_64-pc-windows-msvc": "40e4194f3abd9c1eb97c3783009571f96d83e80018662c4ff6fd60e992b50ee4",
+    "2018-11-09/rust-std-nightly-x86_64-unknown-freebsd": "ab8a32d8efb0ab4686526c6cf1380161e87a89015464f5d5f5438c99723675c7",
+    "2018-11-09/rust-std-nightly-x86_64-unknown-linux-gnu": "1418ba09f97c6ba91e2df5ba0b11cf1c53498710bc6a147fe8f4be455a96c4d8",
+    "2018-11-09/rust-std-nightly-x86_64-unknown-linux-musl": "3262404dc8b0f509b3d47413340d825f99940f954ad4928fc0b39e2032c58230",
+    "2018-11-09/rustc-nightly-aarch64-unknown-linux-gnu": "167fec713804d8af1fa4f543e79ca5cee259f1b966b8e04c99efba75901f4c8e",
+    "2018-11-09/rustc-nightly-x86_64-apple-darwin": "55ca5ad85b0afd61a419e374f8e6320b4f4fe30f8092005cdec9e63103812ea7",
+    "2018-11-09/rustc-nightly-x86_64-pc-windows-msvc": "dd19c5a4b209a9f46dd2f99eb7ec0898bd00accf1c6e8a97222c580bcf62e32a",
+    "2018-11-09/rustc-nightly-x86_64-unknown-freebsd": "bd6bb0228aeab01f425cb2ad55b2e0409b43e79450c2830183a6878cc2d2bdc4",
+    "2018-11-09/rustc-nightly-x86_64-unknown-linux-gnu": "2c475f886123353c9388322da6e13a67b6ae902d8c249f8e95fde67429f7bf37",
+    "2018-11-09/rustfmt-nightly-aarch64-unknown-linux-gnu": "159353d0fc3b7d6aea127df348d7e824da79f995bf286df0bf03ed0615b7e875",
+    "2018-11-09/rustfmt-nightly-x86_64-apple-darwin": "940a39cc86d1cbb02535065d40993cc52acb223487c9efd4ce396950b6a72ed6",
+    "2018-11-09/rustfmt-nightly-x86_64-pc-windows-msvc": "896305dd7fb4975ccdf54c569faf05ce0ff9a13fb0b226904fb6594ed5e5c03a",
+    "2018-11-09/rustfmt-nightly-x86_64-unknown-freebsd": "7c313ee99e0bd3ac8ec13b576b07e6e64b0eed22505ddef1710bf2c7b1236378",
+    "2018-11-09/rustfmt-nightly-x86_64-unknown-linux-gnu": "4d1dbb88662353ea4bc353ec4d73600d72af0fc51f54dc3f0b8ee0b0aef05a15",
+    "2020-02-16/cargo-nightly-aarch64-unknown-linux-gnu": "2b9e7a1be3d4599e22e3070703e76643c12a60b16109f1bcba114d9453d41e48",
+    "2020-02-16/cargo-nightly-x86_64-apple-darwin": "c23632fbdc4a64b53bdc6a0c439a5b8a496e4450805b1ed421258822a4124175",
+    "2020-02-16/cargo-nightly-x86_64-pc-windows-msvc": "f81d3f8baecbe6b461836e667fc6035df50d645a84c58ba1d294a53a654323be",
+    "2020-02-16/cargo-nightly-x86_64-unknown-freebsd": "a2933a0e3092320705a0fa4a9dccf32e6a6566bd7c1440554a2285a98279ed50",
+    "2020-02-16/cargo-nightly-x86_64-unknown-linux-gnu": "658813da4742c713a7486e65d258c45492847c0a3508f041da187d03a50be8fd",
+    "2020-02-16/cargo-nightly-x86_64-unknown-linux-musl": "b197fce52a420f4d91c25794c4ffbc20d10a14918a299d1f8e8c93acb415c42c",
+    "2020-02-16/clippy-nightly-aarch64-unknown-linux-gnu": "47a8f75f95c105fa77fb2807224041801db639441608512be218c39acedf0001",
+    "2020-02-16/clippy-nightly-x86_64-apple-darwin": "d388e393a0cad72bdff876a99b2e5fe9f6c0d2c606a6184630aeda1ef4a06f76",
+    "2020-02-16/clippy-nightly-x86_64-pc-windows-msvc": "783fd1a17cf99c8193a3b884c80768175e7216b3e7c9a38a9fe4348e3bf66bd2",
+    "2020-02-16/clippy-nightly-x86_64-unknown-freebsd": "ff5e128ebd9fe15ae3cc4953f937f92338e332054c1deb3d42b967c2e2a345be",
+    "2020-02-16/clippy-nightly-x86_64-unknown-linux-gnu": "3e52e6fb619b84e3cb36cc42be3c21599c1e6b72fb8738a5c8703d401f69afcd",
+    "2020-02-16/clippy-nightly-x86_64-unknown-linux-musl": "1f1d448068a8bd58d8ace58ec201d5c55d492610ba74c4a8e0ed129060b290d6",
+    "2020-02-16/llvm-tools-nightly-aarch64-unknown-linux-gnu": "f0de4de8e364ee8e0aefc07500caca3917d79ceb4fd52a1602b5985b4c40ec71",
+    "2020-02-16/llvm-tools-nightly-x86_64-apple-darwin": "b9ec36e5c51f2dc1051e4b5831a49c096836f95c8bb87c19d6fa12bcacaaa914",
+    "2020-02-16/llvm-tools-nightly-x86_64-pc-windows-msvc": "4a2b966614e6bb7a1fc054ce42707c8a2b082b2f28c76c8954a19a65ea35476c",
+    "2020-02-16/llvm-tools-nightly-x86_64-unknown-freebsd": "235fa158239a4b498846eebff92639a87c708056e1a91215377f0d485e354c08",
+    "2020-02-16/llvm-tools-nightly-x86_64-unknown-linux-gnu": "f066cf2b315d0b6edc95d1b5b1b5b7a2275928045f4b2e4329144ca9cee85b6b",
+    "2020-02-16/llvm-tools-nightly-x86_64-unknown-linux-musl": "ad60578632fccc91b8503a1baa7f15629c07ffa0572c43a704cc1316ba138894",
+    "2020-02-16/rust-nightly-aarch64-unknown-linux-gnu": "9edd6c4c0d1b8626c905d91d36330fd9c2671d33f82d5bcd4413bb8696fb628f",
+    "2020-02-16/rust-nightly-x86_64-apple-darwin": "608d8747aa928b128b4da9565327fe791ebc787b96e80f09ef84676f3a0a3efc",
+    "2020-02-16/rust-nightly-x86_64-pc-windows-msvc": "735f5f2762ff94b04e70209e46a57202a13a65a8b12a403b620f0896c4fedaa2",
+    "2020-02-16/rust-nightly-x86_64-unknown-freebsd": "69dfcc2b029da84f68c5d543af8262a4735be574a29035d34e452932fcd66643",
+    "2020-02-16/rust-nightly-x86_64-unknown-linux-gnu": "b4f6ce68cc5fde78dc7ab06db6a6f30abde85ba6e5360ea3f75fb8c80232ad38",
+    "2020-02-16/rust-nightly-x86_64-unknown-linux-musl": "0e6b37f73853ac4cde22e883abf4251fc8af2c83565a949159c6c0c41177e8cd",
+    "2020-02-16/rust-std-nightly-aarch64-unknown-linux-gnu": "ef3c2edd450ef3ef214a5cc412de4527631f9324a28168997233a9ebea6f08c9",
+    "2020-02-16/rust-std-nightly-aarch64-unknown-linux-musl": "e1093f086fe07fb3bfb9e9a4c5298fa6eb505b9775f7667322de019b18296de8",
+    "2020-02-16/rust-std-nightly-wasm32-unknown-unknown": "dcc9ce64c62e2100b35194b6a9ed3d9a7572e1bbf28ca09da687af82ff1dbfc9",
+    "2020-02-16/rust-std-nightly-wasm32-wasi": "6e3c13f44ea6e997b5fb0a3818ee8cb850c9654857a438f6e8df42a6e1decf75",
+    "2020-02-16/rust-std-nightly-x86_64-apple-darwin": "d391be4bdb713356fb34cdc03475a830e6bd4476639c46ef19a8a4c05513bc4a",
+    "2020-02-16/rust-std-nightly-x86_64-pc-windows-msvc": "5881bc3954fe5c7a8080176aac4fae95bc079d020c9c68f9fc7d1064470c4493",
+    "2020-02-16/rust-std-nightly-x86_64-unknown-freebsd": "6575eabdfaed4b0490cdfffcbb5860036dcc36bebdabc58d839c088ff5556a6f",
+    "2020-02-16/rust-std-nightly-x86_64-unknown-linux-gnu": "28a169e9b0f0986a50254caf14be863cf6f1ed3aec8342a7fa756dc1af76f38b",
+    "2020-02-16/rust-std-nightly-x86_64-unknown-linux-musl": "fbcba5f59fc47157208a28786a9cafd4046359fc821c568afe798721f5bb4f68",
+    "2020-02-16/rustc-nightly-aarch64-unknown-linux-gnu": "e9cf265820f69331abc9a7c4da0c26febffd4017cf4e6d0840d4ed22b3dd332b",
+    "2020-02-16/rustc-nightly-x86_64-apple-darwin": "db0338b3e1934147dce0bf6420d9c147caa6aef2db1aca44ca8fef47b7247615",
+    "2020-02-16/rustc-nightly-x86_64-pc-windows-msvc": "d51440d4004e49670c5cf803f96aa222c68f09348bfca46f6e0d4c8728908065",
+    "2020-02-16/rustc-nightly-x86_64-unknown-freebsd": "c76fa125e6d17b16a96b01a875d826f20849b09970b49ed1183601a0e7803f6f",
+    "2020-02-16/rustc-nightly-x86_64-unknown-linux-gnu": "456af585ad4408ab5f0c7500264ebb4a5f6338c0aed642edb81224ec6146b546",
+    "2020-02-16/rustc-nightly-x86_64-unknown-linux-musl": "a98a07ecd9d291e3788d7e2d0dce82adb3777570afdfbe5707d05360d058fdb7",
+    "2020-02-16/rustfmt-nightly-aarch64-unknown-linux-gnu": "76b5fb48db5de274950f86a9b1cb69738311d2302da3e079ec772302aacfd999",
+    "2020-02-16/rustfmt-nightly-x86_64-apple-darwin": "77b467fec83ea6d8f2b4e4e186806d77ae7ecfab1de618f4a7d857aaa7f6823f",
+    "2020-02-16/rustfmt-nightly-x86_64-pc-windows-msvc": "eee4d08ac820d85491a9f13909f178dbdcc54edc5d98d2e433a073c6b1aa611a",
+    "2020-02-16/rustfmt-nightly-x86_64-unknown-freebsd": "a47062919f16888d2baa58a640299a5a9ece3f0d6537dea6e6241ac0d8877e7c",
+    "2020-02-16/rustfmt-nightly-x86_64-unknown-linux-gnu": "65513b8ca698f6859af19be665bead97271e7dbac3bc6058256ede1d7340aea5",
+    "2020-02-16/rustfmt-nightly-x86_64-unknown-linux-musl": "ac3275329a7f08749f8bbd08a9c183e24ad0a58c02e7cf70e81c41030a886900",
+    "2020-11-10/cargo-nightly-aarch64-apple-darwin": "cb4578ec077cfc56c3b23c59d4bf219aa05f0dbe5b431792d0860ed121e3619f",
+    "2020-11-10/cargo-nightly-aarch64-unknown-linux-gnu": "de75beda2e7c9501c88874e9769101204f1726eb7b26b79c4d8c162f4b2b7eec",
+    "2020-11-10/cargo-nightly-aarch64-unknown-linux-musl": "0292763ac22b539d4d17d7696fa649dccb8ba0f90c86f8ffeaac961add976c39",
+    "2020-11-10/cargo-nightly-x86_64-apple-darwin": "ad4add153d93e7db296560da01fe92c8c975d444e33bab4869ed10cdf2023e48",
+    "2020-11-10/cargo-nightly-x86_64-pc-windows-msvc": "ab5bd83e8fdb079f20c1f3623d334972d831bb5a339c8450f82a1034124ff72f",
+    "2020-11-10/cargo-nightly-x86_64-unknown-freebsd": "72ab8898aea8bf1f030da12ea3b4d1dbc18e5f7c2df28282fe915390f12d7939",
+    "2020-11-10/cargo-nightly-x86_64-unknown-linux-gnu": "82b6b0c0f20d4d23b769d79b6122cb7a074d9f222325b07503eddd73817452b5",
+    "2020-11-10/cargo-nightly-x86_64-unknown-linux-musl": "bae2a597c7c2ad907d49c6420bf85f91ea754cfb771d39d8b734c8d30563352d",
+    "2020-11-10/clippy-nightly-aarch64-apple-darwin": "c874202231fc418dc3fea539440d413c82d354957b25fb355e8afb01b8624d9a",
+    "2020-11-10/clippy-nightly-aarch64-unknown-linux-gnu": "f2730540761a100dcec0c36773411f69e74dc1ca96c67bc0ac61e6567f84a422",
+    "2020-11-10/clippy-nightly-aarch64-unknown-linux-musl": "be671660b1f8d347e69e7ae1e7d86f239b9d865245f97b790cd89738363f79b8",
+    "2020-11-10/clippy-nightly-x86_64-apple-darwin": "5ddbc1e21dbad3af73d8d0618439ec48b0432b392989f86b9e81d952badb4d16",
+    "2020-11-10/clippy-nightly-x86_64-pc-windows-msvc": "03232d753f7b5d5f384352bd4da99aa19d476e9d90fdb4975fed49f0fb4f1ba0",
+    "2020-11-10/clippy-nightly-x86_64-unknown-freebsd": "ba070cc03d05d50c00c106742fbd376ee770c0b81cdbdde549caba1535f290b5",
+    "2020-11-10/clippy-nightly-x86_64-unknown-linux-gnu": "02e23757d51c8fcedcedf02ca336a36bd13b45bdad5abb0931c9028e7228b406",
+    "2020-11-10/clippy-nightly-x86_64-unknown-linux-musl": "862dd065e8933b83c17902aaee3f20a48ff67e034f6b7c7ec05ea49e240d0ad3",
+    "2020-11-10/llvm-tools-nightly-aarch64-apple-darwin": "e2b1803548aeedb1e6b51724c9cbab123626fc88846eae53adf0a1c55d4a364e",
+    "2020-11-10/llvm-tools-nightly-aarch64-unknown-linux-gnu": "442255a2859c2e3345c8ceea7a28359fb02d42460ecf51d92395c1dd85c9a8af",
+    "2020-11-10/llvm-tools-nightly-aarch64-unknown-linux-musl": "85de8206f0ea17b51bf1ff3154d9afd6855c54e6b33babea22ec512cf837c283",
+    "2020-11-10/llvm-tools-nightly-x86_64-apple-darwin": "9ae35e98f8f930257bb103ae1cffda42476338838f490a62ba9d93638ce122ec",
+    "2020-11-10/llvm-tools-nightly-x86_64-pc-windows-msvc": "4106227bf29d1dbaa35ddc12f8a2c2f16ef27fe21971f6f7ed0d4356691a4055",
+    "2020-11-10/llvm-tools-nightly-x86_64-unknown-freebsd": "91dbd775c36f8b29bd688a1e75b10ab065928622985aee7e96848952ab6d85d9",
+    "2020-11-10/llvm-tools-nightly-x86_64-unknown-linux-gnu": "532a0883b16bbaa70bb2e9ba6c769594db35b1aaacbfa9ef06631a91bfe8048a",
+    "2020-11-10/llvm-tools-nightly-x86_64-unknown-linux-musl": "fc476f62ae3a917a634afaa3fba83ee756799de11b7bb0af38a9d85e75a1a66c",
+    "2020-11-10/rust-nightly-aarch64-apple-darwin": "bcb30524c7f4520bda573d31962ce5b058cd9b6d05db83431b182483071fb429",
+    "2020-11-10/rust-nightly-aarch64-unknown-linux-gnu": "7d6453eaf2640a9979707e6ef92b8dcfed33bd7bf5a7696d8efdab05bed182d0",
+    "2020-11-10/rust-nightly-aarch64-unknown-linux-musl": "b25c99b1b0f8aa36d17f86677b040bd73e2d2128938b0bfdf6cbcb1782783001",
+    "2020-11-10/rust-nightly-x86_64-apple-darwin": "106395f200ef0e6d08baad05d5da786dd17c612d25ba5d7c65a7031d52af9bd5",
+    "2020-11-10/rust-nightly-x86_64-pc-windows-msvc": "6a28970950157102e0ea6799da0235483cad141b2cf112718abcaa19ed81170e",
+    "2020-11-10/rust-nightly-x86_64-unknown-freebsd": "dce8b0971da6c265190d0c14cee3e4d82ad24ca224398ef3002a870f3db31fce",
+    "2020-11-10/rust-nightly-x86_64-unknown-linux-gnu": "29696ffa840261dec1a27018054599a93f49facfa6813f7ad1a875cfb1fc6fd7",
+    "2020-11-10/rust-nightly-x86_64-unknown-linux-musl": "a9f599adc294cbbd73e56efbec0d14306cb2da15f39fe0584969ffca4b00b86a",
+    "2020-11-10/rust-std-nightly-aarch64-apple-darwin": "80e57cd44992e0a9a29bb0233a4c7301369c7f00e9a63f89e944c5fd75931d40",
+    "2020-11-10/rust-std-nightly-aarch64-unknown-linux-gnu": "a4d0fa574f93e530f421651ec38f5374fdc8be20de717c435750bfcf0ae15f36",
+    "2020-11-10/rust-std-nightly-aarch64-unknown-linux-musl": "b1921c71b00cc8c8b665275ba4becaef16e860b88d4fcd2c6cae31cc6f929d14",
+    "2020-11-10/rust-std-nightly-wasm32-unknown-unknown": "636cb560095c23e12d629ea21dc85af954c2fcb2df57f25b40f11826d7547a46",
+    "2020-11-10/rust-std-nightly-wasm32-wasi": "baf705571736331dd5449e1473b590477e2a48ad0adc6a897516fb8f1a5780fd",
+    "2020-11-10/rust-std-nightly-x86_64-apple-darwin": "2b0d1758c20fea48e8afa5c9cc2844e9eb5c77376992f2af1e68261e1b0bd773",
+    "2020-11-10/rust-std-nightly-x86_64-pc-windows-msvc": "9e5f1089de87e9d54417038f7d5d30de5e604bf82f5be557361cd02b55abb018",
+    "2020-11-10/rust-std-nightly-x86_64-unknown-freebsd": "24a506f85e178be0799d12f9354c6129004068552c8f5321a519b033631b815d",
+    "2020-11-10/rust-std-nightly-x86_64-unknown-linux-gnu": "367c14b7fbe98e264b0e4b5a9ddaf3f78ce3ce09bbef4c7be33a3f2abade9ad9",
+    "2020-11-10/rust-std-nightly-x86_64-unknown-linux-musl": "b2e929d3821b104796dbc0521228cef25ce6f55e3494dfc7c3a852b6404c4acc",
+    "2020-11-10/rustc-nightly-aarch64-apple-darwin": "a461f2486013b5cec450c8f79230e83878689b803a38df7304adea27b025ef1b",
+    "2020-11-10/rustc-nightly-aarch64-unknown-linux-gnu": "900170006c4c2d88cadc0d915d410588cb80150817e53aa7fca41a459a5ec500",
+    "2020-11-10/rustc-nightly-aarch64-unknown-linux-musl": "bf8d81b551229263f52ecfdd561ba6698d7030832723e5c3721d5ada5d478e7a",
+    "2020-11-10/rustc-nightly-x86_64-apple-darwin": "7a443dfb068bb7e3854dd6475564da33a57d3f225ce03ad8bc973e8900960b69",
+    "2020-11-10/rustc-nightly-x86_64-pc-windows-msvc": "e7b325e55d372aaf4be400273673711fe78271b655c0b710d62a972b8044b9ef",
+    "2020-11-10/rustc-nightly-x86_64-unknown-freebsd": "3ef55f82aefad5eac4398977d34b1963feb05b1cd654005d385da26624cb2f7e",
+    "2020-11-10/rustc-nightly-x86_64-unknown-linux-gnu": "7498af27587f4ff235b0477199eec4128a65f54d4c05e4ddb9c632685ec526b4",
+    "2020-11-10/rustc-nightly-x86_64-unknown-linux-musl": "ecb5626e23ea84e1b14fe064b6fb1afc145ec280356a6f197ec410c23756f217",
+    "2020-11-10/rustfmt-nightly-aarch64-apple-darwin": "e4e992764d26792ba901fe4c9590cbb7a72a8a71b524f54ae7b1312d2824bca4",
+    "2020-11-10/rustfmt-nightly-aarch64-unknown-linux-gnu": "7ec62c4aaa8a89f94e037c39907caaea942c9fb44e5dbadd65be7b9c8650c594",
+    "2020-11-10/rustfmt-nightly-aarch64-unknown-linux-musl": "5324c21a1384ba88a2f2552386050b566a3c48673949218b65e26b6ecbe04c6a",
+    "2020-11-10/rustfmt-nightly-x86_64-apple-darwin": "c169fbd9b21ddff9e7558f8674755410d170aea6521cccadd06a14d1091870c3",
+    "2020-11-10/rustfmt-nightly-x86_64-pc-windows-msvc": "d3fa6a30d2be44c636478c0259337c6f449a55bd9f037cbe0600a18da143c2e5",
+    "2020-11-10/rustfmt-nightly-x86_64-unknown-freebsd": "3681fa62a68c50d0de839dfe424e30ae72d8635e15267042191bb10195d265fb",
+    "2020-11-10/rustfmt-nightly-x86_64-unknown-linux-gnu": "75e17c1e4bcfa70669aefda8ba34a7e8d6e0f5d842096b98135f3447b37d3538",
+    "2020-11-10/rustfmt-nightly-x86_64-unknown-linux-musl": "84bc7707f7ce989c1ed452817153c25fc7324d1795650787fde878ac862ecfda",
+    "2020-12-30/cargo-beta-aarch64-apple-darwin": "6c0f23ddbb4e75155d1dfc24fd9103651eea565626f8b4c292ae09b17ef287f5",
+    "2020-12-30/cargo-beta-aarch64-unknown-linux-gnu": "ae0c5595646ae7a532b5f14720b67a82875b6d4bfdc6c8a2982d7c40e0d9f318",
+    "2020-12-30/cargo-beta-aarch64-unknown-linux-musl": "e6d576a7690ec8f16c93899b3cf5daab1608c6e4bf18fdd8462a0a61180e13a9",
+    "2020-12-30/cargo-beta-x86_64-apple-darwin": "07b59728f4ac5f95ff8fec3813e8ae1afa4d00105e490866373ba99ff25bc142",
+    "2020-12-30/cargo-beta-x86_64-pc-windows-msvc": "cebcf3f6f2a502ac53be02cfc3522c9bb6ec4954ccf93cc12026028102706900",
+    "2020-12-30/cargo-beta-x86_64-unknown-freebsd": "9975b922979a74c48b8461d2c67086565fa84b4f2be8857b5027d9f1db9e7cb1",
+    "2020-12-30/cargo-beta-x86_64-unknown-linux-gnu": "cce34205c11ae5f6c1c2fe08aedf1448d0f7bd8e11d3a7e467c12e46595d5372",
+    "2020-12-30/cargo-beta-x86_64-unknown-linux-musl": "ba71eeb40ca9ccd8d8b356fad1b7d6cb7af4f982a00b5feffede345895104561",
+    "2020-12-30/cargo-nightly-aarch64-apple-darwin": "8ac787c50ad37ab398d504cb915987ca85d87372a224564935aa1203d4cb5477",
+    "2020-12-30/cargo-nightly-aarch64-unknown-linux-gnu": "81195f8efae71dd6f96bea9ba1881bb647d127a130570289d026ea55a43ce6e5",
+    "2020-12-30/cargo-nightly-aarch64-unknown-linux-musl": "220ef2d21821c6c358a1672d4895389e09b78d4ab7270453f48785b9974b1901",
+    "2020-12-30/cargo-nightly-x86_64-apple-darwin": "28cfbe0214e99e311c58ae2fbcd23ccf9d31d97fcae106adf174f8e697416d4f",
+    "2020-12-30/cargo-nightly-x86_64-pc-windows-msvc": "80678407f5b2bc1cd01b36fc06105b1035740b9002f728629f3555965d0a977f",
+    "2020-12-30/cargo-nightly-x86_64-unknown-freebsd": "812501b738c59027b61ef6ac2462f0be76d4a95b9c78a301ef6dd33b225ca5e8",
+    "2020-12-30/cargo-nightly-x86_64-unknown-linux-gnu": "3d16880431ec9a218808806d6b768c7e29cc9ee6298a4dfa796f0fd5bef9cac3",
+    "2020-12-30/cargo-nightly-x86_64-unknown-linux-musl": "c4798bc41dc9a65b23962b0250cff14c648fe6804d0b96df9f59460a0741e916",
+    "2020-12-30/clippy-beta-aarch64-apple-darwin": "b3535c7e1c72d5380518ab2568762f38c9a359310664b63ed14c15b9ff4b4528",
+    "2020-12-30/clippy-beta-aarch64-unknown-linux-gnu": "15330ccfd8462712546e34c07de4f921df74798204d1dcf325e1c2df9f741b00",
+    "2020-12-30/clippy-beta-aarch64-unknown-linux-musl": "61d7532e94d1837dda778e0140f42384696896ed7ff22a1922ace833a1cbf2c0",
+    "2020-12-30/clippy-beta-x86_64-apple-darwin": "70161007d54df7ee2cbd2f6fa115526f9a426c7f4dd9570c97577aafb33ff96b",
+    "2020-12-30/clippy-beta-x86_64-pc-windows-msvc": "9eef81fc0e6dddd105b871dc13834c99deaefc022a06844b191a6ebf3c266b4b",
+    "2020-12-30/clippy-beta-x86_64-unknown-freebsd": "519b646b3e23c38337e1a50275413580e697dea680a8ef40feb0fb1331ca5da2",
+    "2020-12-30/clippy-beta-x86_64-unknown-linux-gnu": "73aab1813c75c7efc14d957cbef40bd951e1b195ea2f025cec1fdd100acd3203",
+    "2020-12-30/clippy-beta-x86_64-unknown-linux-musl": "fd65821d39cf177493abf58063b2a2592403cadf4d319ed72ba99ff06b0503ab",
+    "2020-12-30/clippy-nightly-aarch64-apple-darwin": "15d33adcf937fddd4b27a86b0153d418fd1cfe148e901c11f69a7b62f9025363",
+    "2020-12-30/clippy-nightly-aarch64-unknown-linux-gnu": "09abbf8fa7d941ba4d815476b51ec96a3c138d4193971f1a765c7218da819e78",
+    "2020-12-30/clippy-nightly-aarch64-unknown-linux-musl": "e0e334fc4ffdce118cd2bcafea2cc49aef0bb9cf69e5775cee80c5950bc8f60a",
+    "2020-12-30/clippy-nightly-x86_64-apple-darwin": "1c18a16194a89a18ee727c18d655d613e05c3c115f6acb35ab4d2aa03ed047d1",
+    "2020-12-30/clippy-nightly-x86_64-pc-windows-msvc": "7a417a7e816a357ff09c711fda1c0f1c3b8dab10f81a9423e8e6ea63f1696030",
+    "2020-12-30/clippy-nightly-x86_64-unknown-freebsd": "71d41007415ea347dd347b34468cb307e88578bc095455d7d88e174a8546ae22",
+    "2020-12-30/clippy-nightly-x86_64-unknown-linux-gnu": "6dcc3aca82ff7830b89506386bd212724b265913d553c32c83ac534c500b7cf4",
+    "2020-12-30/clippy-nightly-x86_64-unknown-linux-musl": "ec2108da23dfb5f1799a1f42c2c8d6a5d72a92321b4000935d5ab29fcb9e67e2",
+    "2020-12-30/llvm-tools-beta-aarch64-apple-darwin": "d6e3e50a19aa45863ba5e37f316bf928f6eca96c3fa749b9ba87cddb3608a659",
+    "2020-12-30/llvm-tools-beta-aarch64-unknown-linux-gnu": "e1f3d55116386fbecdcaacb879dc19a62a9c9bb0d06581a366a53e84a5bc4d8e",
+    "2020-12-30/llvm-tools-beta-aarch64-unknown-linux-musl": "f0e7a5df202982f5ec91dd0d0bed875976906df8b64fe56702f452e7bda20654",
+    "2020-12-30/llvm-tools-beta-x86_64-apple-darwin": "b5a1a1b3d2d316e8d66876736462b6c8b08951e7fbfa3568da19caeb976e9fa9",
+    "2020-12-30/llvm-tools-beta-x86_64-pc-windows-msvc": "a10198ef08e9e58bb1a54ec23368d5df02c87b6618e16ab026afcc5c8f9cef6e",
+    "2020-12-30/llvm-tools-beta-x86_64-unknown-freebsd": "79df94c33935de84d0cd0e985c333c2516551a9fab3c8fb7c5b93cf3b0d0e22e",
+    "2020-12-30/llvm-tools-beta-x86_64-unknown-linux-gnu": "6e4d8501fc7c5c69b4a5b532021a0e39e125b6fedc12b1afe4ba22d07e0b995e",
+    "2020-12-30/llvm-tools-beta-x86_64-unknown-linux-musl": "19b0382c59426db81004a4386530fa4e8981dfc2feb5bc8224ad1924e092755f",
+    "2020-12-30/llvm-tools-nightly-aarch64-apple-darwin": "8e2f796ace0270fd2fde8bffe4db90fa1b09947032ee705bd99a1628a1138b95",
+    "2020-12-30/llvm-tools-nightly-aarch64-unknown-linux-gnu": "3f59253b666c05faef7a3b9b1b761ac6ae4f83833996495936629f41fc4c6959",
+    "2020-12-30/llvm-tools-nightly-aarch64-unknown-linux-musl": "e6a109c5d3c90969f37d7f0fbd43346616ba8322dca9046a0ea7d522230f71a3",
+    "2020-12-30/llvm-tools-nightly-x86_64-apple-darwin": "8aca7ddf73983bf2db4846721787547fed16c2ad4dc5c260f7f05f6b93cea8e7",
+    "2020-12-30/llvm-tools-nightly-x86_64-pc-windows-msvc": "f30202ade378ade7a1a4bf23381ae69525154ce009aa54b9d59d6507000bf301",
+    "2020-12-30/llvm-tools-nightly-x86_64-unknown-freebsd": "7f1837f6c8e26232cad456df8ce9104cbc6eea8a57e3290a8c72286c0e9fe803",
+    "2020-12-30/llvm-tools-nightly-x86_64-unknown-linux-gnu": "b1ee3b5cafd026432c74ab9eda4f797d1aa55d06a38438f84f29be528887e540",
+    "2020-12-30/llvm-tools-nightly-x86_64-unknown-linux-musl": "7f97270394c389db0feedc163c134518e1ec2f28910db22ed4fc50a61c2a9d4b",
+    "2020-12-30/rust-beta-aarch64-apple-darwin": "eb202137d6801bf50c3edc06b5bf16cd5215c66d24790a1168d22fb3a504adf9",
+    "2020-12-30/rust-beta-aarch64-unknown-linux-gnu": "c1d80d58cd0eb74f3db650285c808d18fb0a195fe7ad6461c38de098ff94fc77",
+    "2020-12-30/rust-beta-aarch64-unknown-linux-musl": "a7e852fa55fe8183d749196f72606c1541fb85de7bbd58a73df45454d5cb6e0c",
+    "2020-12-30/rust-beta-x86_64-apple-darwin": "ed1b3b8f5fe4e73ddef62a54ec41dada5fb2cd2519f5c5add06be6ea57c38d49",
+    "2020-12-30/rust-beta-x86_64-pc-windows-msvc": "0192de1b6cb415683e231caf3817127230828e6256150cf0a0c8f393cec50650",
+    "2020-12-30/rust-beta-x86_64-unknown-freebsd": "23515e664a0a87bd217bbcdec8785f52485ad8f74c7ff84b6949c0a16f09be1b",
+    "2020-12-30/rust-beta-x86_64-unknown-linux-gnu": "5ebe5cdf55eb79dad2c34fc770c5a35a6be2ef2a72865db291932ca193467b6d",
+    "2020-12-30/rust-beta-x86_64-unknown-linux-musl": "f33120cbe25113f956c035b3c2ca532eaf810ab6d85c6df69fff0eb69e1547f5",
+    "2020-12-30/rust-nightly-aarch64-apple-darwin": "4cc5ef6dc2e7524da659e416b68b353f61576aeefccc33c0f2564699d5d0cf91",
+    "2020-12-30/rust-nightly-aarch64-unknown-linux-gnu": "1539f5181c1993abb7a43b14dd1294d88453e48f8670c4574e0b5e98e6df28fe",
+    "2020-12-30/rust-nightly-aarch64-unknown-linux-musl": "7ef640112eb50bd77c7203d5fe56bcf3b2fba130e4acd5e707056686431a93a8",
+    "2020-12-30/rust-nightly-x86_64-apple-darwin": "2b5b885694d0d1a9bdd0473d9e2df1f2c6eac88986e3135e6573e1d71e7824dc",
+    "2020-12-30/rust-nightly-x86_64-pc-windows-msvc": "2c9086371cee98ce95cf10098cd655b2e33dd70e8e250759a1e8b0e8c42d659e",
+    "2020-12-30/rust-nightly-x86_64-unknown-freebsd": "79e5492d9a5f9f04ec5080be1fe305a3d7adde330f5c3fb9d7a3bae52720a027",
+    "2020-12-30/rust-nightly-x86_64-unknown-linux-gnu": "1a6b541f2d0ccda148a60d749e974cc545d9765b71d8dec59418b493f05209a2",
+    "2020-12-30/rust-nightly-x86_64-unknown-linux-musl": "fe9c7f0c0898b1f54d0a3492450580d2abb7682de74a9964e60eeabb7761a3b1",
+    "2020-12-30/rust-std-beta-aarch64-apple-darwin": "0065919e445e3eaa8d70561b949697b8e3af9beea62989c9ffc60856d46a9da3",
+    "2020-12-30/rust-std-beta-aarch64-unknown-linux-gnu": "426bd1cc7a0e94af5decd643d08c54fe9aab29e638cd79aca21ccb05ec00eaf8",
+    "2020-12-30/rust-std-beta-aarch64-unknown-linux-musl": "d9f779f46c182b37b185113f92e8a8a17ebf3b5ef4e11e137980fdf7139ab506",
+    "2020-12-30/rust-std-beta-wasm32-unknown-unknown": "3cf97eba1da6d14160e82de4c0302883fb2eb9c65151dd2a148c57cba430f5ec",
+    "2020-12-30/rust-std-beta-wasm32-wasi": "e86f3f58cc04bf4c4f9d94ac11e7244510a35f89795298658de2153a7fa60f86",
+    "2020-12-30/rust-std-beta-x86_64-apple-darwin": "12f5a181b6102f75e85b71259283d852777940cf82d1681fb19005b589076a83",
+    "2020-12-30/rust-std-beta-x86_64-pc-windows-msvc": "a02da2dbd7f3d14e4a2083a497aa7aa884b99e6ea941059102278dd2325c5b61",
+    "2020-12-30/rust-std-beta-x86_64-unknown-freebsd": "379f353e27b8218ed6bb54f1ef16314624705e9b28f5cd6047bc25259aeb0bf6",
+    "2020-12-30/rust-std-beta-x86_64-unknown-linux-gnu": "6929f00e1cb93b16bd2e3d76029b297f099818183ac2d7ff23eb532d4c31ebb6",
+    "2020-12-30/rust-std-beta-x86_64-unknown-linux-musl": "789ccd43b76e3f7af1675d24780281191be48991a2b2a217acd306b534bce4b9",
+    "2020-12-30/rust-std-nightly-aarch64-apple-darwin": "a01bcc6eb93b1883bc57739959d6f9e13fbb80e1867310272cdb1a1de496cf73",
+    "2020-12-30/rust-std-nightly-aarch64-unknown-linux-gnu": "3997bd9e5057851b9e49ebcba5886ca98bf736c062c122e677fcf40aa7ac5416",
+    "2020-12-30/rust-std-nightly-aarch64-unknown-linux-musl": "628f5ef4fd2e8b8d7e429a431127cb65321a69fbb69ed07b27df6ac4c8850784",
+    "2020-12-30/rust-std-nightly-wasm32-unknown-unknown": "b1669be863b7f419254382e9e3820e9ef0d69c60fa45f91d0625140229725484",
+    "2020-12-30/rust-std-nightly-wasm32-wasi": "8f2b0a30cdf50d748e57d23d94d54a4e175e864296c8048c8454bb6198b16fb0",
+    "2020-12-30/rust-std-nightly-x86_64-apple-darwin": "17912a6a5aa56daeb0aed5fca8698bacc54950351d9f91989a524588e37e41ca",
+    "2020-12-30/rust-std-nightly-x86_64-pc-windows-msvc": "4d2585cb12606f217150509971850330cc1b7f3e1a9c18ce03fd3b981021fa1f",
+    "2020-12-30/rust-std-nightly-x86_64-unknown-freebsd": "ac517f0ccc4b30f3a296a25a8b17f75f877052cd56ae5c5a043d88c0f5de972b",
+    "2020-12-30/rust-std-nightly-x86_64-unknown-linux-gnu": "5b1bd5fa31b9190c66b3446629c155d4896cffc8fb1f9f603a2e949162b7f791",
+    "2020-12-30/rust-std-nightly-x86_64-unknown-linux-musl": "3802d2c7271cdd3fc35921b0d9f999b9b34ac9d888b62085b976453a8b113700",
+    "2020-12-30/rustc-beta-aarch64-apple-darwin": "20107f4541be8822d428c402e010333f2f00aaf086d03b4e35ce8d1bd5c33d5a",
+    "2020-12-30/rustc-beta-aarch64-unknown-linux-gnu": "29e2808cadf8da481a0ace30bf107372dd108b0475706cbe2b9cdd4ff27e2315",
+    "2020-12-30/rustc-beta-aarch64-unknown-linux-musl": "035bd303601f588ebc23293e9c64050f7053eca1fb2f3266971bff71c4cc3a1e",
+    "2020-12-30/rustc-beta-x86_64-apple-darwin": "d65df5791d79e13037672d22055ec24583195554cdf7c3c2992cbcafa497e98f",
+    "2020-12-30/rustc-beta-x86_64-pc-windows-msvc": "7f934dd412207c0d776fb4e8ec4c5f4426e92b2a1854416a8ce7bbc2dc7f5908",
+    "2020-12-30/rustc-beta-x86_64-unknown-freebsd": "19818ab53bbd94c6d1723a52809bf1c3a271e258664ea2b3b7d00161965e058c",
+    "2020-12-30/rustc-beta-x86_64-unknown-linux-gnu": "4f5ac3311c913b79dca1a02cf42fd7326c63d53ee252447b61f113c043a82b5f",
+    "2020-12-30/rustc-beta-x86_64-unknown-linux-musl": "d688cfe617d18c132a051afe42ac0c759638b1d2b0003fe7970becd1cf30c8be",
+    "2020-12-30/rustc-nightly-aarch64-apple-darwin": "4610961ab77e1bb54bda95474b1c1f25f1fc5c1c103bc4f54758e5b2a5454d8b",
+    "2020-12-30/rustc-nightly-aarch64-unknown-linux-gnu": "c9997c01769a6371200e20639fcae99e6dec3d9062f65b2928429e04d4cb7930",
+    "2020-12-30/rustc-nightly-aarch64-unknown-linux-musl": "28a24668966faf46f0a79034446e54e2b86e4968e1a3a9381dbf5d9e916d8d9d",
+    "2020-12-30/rustc-nightly-x86_64-apple-darwin": "cf2f06d6c8d784a469561f6323b8b923fb6ad3a7c55c7ac90d5619b9d443ae9f",
+    "2020-12-30/rustc-nightly-x86_64-pc-windows-msvc": "8df3729f3b09cb39fc4b0ecfd90551625941d508f7e776ae4e16fcf02b0af4f3",
+    "2020-12-30/rustc-nightly-x86_64-unknown-freebsd": "f3818645265c3a08cb9fa04d1c2d42be72116974c9c34515feb7d5788e86ac41",
+    "2020-12-30/rustc-nightly-x86_64-unknown-linux-gnu": "79fc8d51bb6d298d292045eb77e1b2d0f7f97886604599a3e9dfc0c6956e49d7",
+    "2020-12-30/rustc-nightly-x86_64-unknown-linux-musl": "2627e995ff9d7e72ec46d9161d3b8f78d264671c507f10337f9ec714171dba5a",
+    "2020-12-30/rustfmt-beta-aarch64-apple-darwin": "75c957da65d459a02f29affd8fac867e14eb8eec98531fd2216ebcb54a5b6407",
+    "2020-12-30/rustfmt-beta-aarch64-unknown-linux-gnu": "b34fd3a8e80969df9ba71ef5b80f143b4e8f325a91d98b00db1ea86879074b22",
+    "2020-12-30/rustfmt-beta-aarch64-unknown-linux-musl": "10353a1a4c052509277625702e6f36a3561772760671728b406cd0d5c1f46e1a",
+    "2020-12-30/rustfmt-beta-x86_64-apple-darwin": "bfe5ef2349a226fe54d87658f55dad90b99ee6e36de4f5d1e381b1ca453e1919",
+    "2020-12-30/rustfmt-beta-x86_64-pc-windows-msvc": "ebac84095df62d8ed6b41454c07f043477479a1770cf156a5c9f351bebcbe6a4",
+    "2020-12-30/rustfmt-beta-x86_64-unknown-freebsd": "bfe8a34403fb19d88eb2b4528b3836a645239d239bf56cc9b916aefebd0199a1",
+    "2020-12-30/rustfmt-beta-x86_64-unknown-linux-gnu": "78ac7e3178068c6828765c295698cb79375266cec95b097c4603f8582bd24379",
+    "2020-12-30/rustfmt-beta-x86_64-unknown-linux-musl": "6d8f4685cc8bcee32c7e5e3b7524444d90c88486f81905e109fbe5cc47f99fc1",
+    "2020-12-30/rustfmt-nightly-aarch64-apple-darwin": "0c3cfa89787cc9fcdee39acc0b5c5cf3ef084d85fb0e2716926813852fb96a3f",
+    "2020-12-30/rustfmt-nightly-aarch64-unknown-linux-gnu": "5fb27d5f31411c242a8046de087b3dbd73e5829d7e07493858034139681c30c7",
+    "2020-12-30/rustfmt-nightly-aarch64-unknown-linux-musl": "19f6b831df8996666d9277396650909b06396fca3b37eeffbe0c763472cb076c",
+    "2020-12-30/rustfmt-nightly-x86_64-apple-darwin": "c7da578f3b70dbfa0ae1f06370c7c9f22a49127fed8a99b69dc9ac6e42491bb0",
+    "2020-12-30/rustfmt-nightly-x86_64-pc-windows-msvc": "ebae20dd198a36b657aa0486e6b557aba60c9b4fbff25c108246de312fd2963f",
+    "2020-12-30/rustfmt-nightly-x86_64-unknown-freebsd": "2e0f2e4adcc234d29859aa38088a02be2b2bb0a7e43863bca6d436a6712b8b3b",
+    "2020-12-30/rustfmt-nightly-x86_64-unknown-linux-gnu": "0fb77ae8a33fb83ea496654a52e55ab5245206322f09c1d396e0c5833a16b856",
+    "2020-12-30/rustfmt-nightly-x86_64-unknown-linux-musl": "a93e4b51ca3e87661edb62d8ceedf20446e7cb2fa700ab9f8cf765db6e5f9407",
+    "2021-06-16/cargo-nightly-aarch64-apple-darwin": "eaf4540191cbb0627b2f6bb4cb9fe94351bb7601d07cd2795b3f1386d32dca76",
+    "2021-06-16/cargo-nightly-aarch64-unknown-linux-gnu": "a46dd7f7d4532df2944056efab6b0f510224497be0993699ee59188b03b462a4",
+    "2021-06-16/cargo-nightly-aarch64-unknown-linux-musl": "11213aac3d92a05799892e94bcf632ea35418eb600bcf7ea71f9c8216c2cdb3b",
+    "2021-06-16/cargo-nightly-x86_64-apple-darwin": "09b55140b655ade515b4890c966e2f8b23e68d96a2deb557c23d520315dc72cb",
+    "2021-06-16/cargo-nightly-x86_64-pc-windows-msvc": "6180250887125396cb2dfae079bbe9a4e71e8432034f7d20428193cbbe4ccb4e",
+    "2021-06-16/cargo-nightly-x86_64-unknown-freebsd": "8d54457bb1d21dfe85889fa29c3fa8dc40d0a9a54b47ac853aaa2136efec8fca",
+    "2021-06-16/cargo-nightly-x86_64-unknown-linux-gnu": "4566ecb0c1b3131f44a14b1851702e6a6bdd06f80fbf0d5d768770a97b10cb3f",
+    "2021-06-16/cargo-nightly-x86_64-unknown-linux-musl": "9b491cb6472197db1f435e30c7b133f4da12e602d77e8ab82859c3181b214b90",
+    "2021-06-16/clippy-nightly-aarch64-apple-darwin": "4241a05e0a53c9385f83956241131c7c7ee4b75b5ce403f992dbd3512c8996e7",
+    "2021-06-16/clippy-nightly-aarch64-unknown-linux-gnu": "c942124cf5d48716e0cc85c8c328e6261b8903b4d86254233367de74036258a2",
+    "2021-06-16/clippy-nightly-aarch64-unknown-linux-musl": "87a5ccb283f5cc5a35271d0de17491e37c1694ab6b3015291a37c1b18cac3f49",
+    "2021-06-16/clippy-nightly-x86_64-apple-darwin": "fe4b7a3f596a118682d9b8fb58ddb1f9b222e679dfd8ad5072050aacc30280d0",
+    "2021-06-16/clippy-nightly-x86_64-pc-windows-msvc": "1605953eb558f6feccd13e13dba581c4336129f9714464148c0958b22cb12521",
+    "2021-06-16/clippy-nightly-x86_64-unknown-freebsd": "2248da8e036e410c124bc24564bb99679f05beff2ab1a6f866cdd111f43ca65e",
+    "2021-06-16/clippy-nightly-x86_64-unknown-linux-gnu": "3308e33e1ccbac22d03a279bb5112d5e089b482b096456e1cee550df651e558b",
+    "2021-06-16/clippy-nightly-x86_64-unknown-linux-musl": "928916f1e52107d92e40732bc8dc3162be1a445974249d5cc1be8c4be5f83dc1",
+    "2021-06-16/llvm-tools-nightly-aarch64-apple-darwin": "9ec6f8a300c7a5d49eecbce1f6a705edccb3b2197691334df4f7cb280e10c701",
+    "2021-06-16/llvm-tools-nightly-aarch64-unknown-linux-gnu": "66ce674917f40309033e8bb4316577679baad14929468c5f023d81b4225a6551",
+    "2021-06-16/llvm-tools-nightly-aarch64-unknown-linux-musl": "a8655b9e3726920a705081fee1add02c26fcbd4b3bdbca52642ad74b16be24ba",
+    "2021-06-16/llvm-tools-nightly-x86_64-apple-darwin": "e1aa13d71478684f83af6b3211b88cc2b370ac84a9f140a78af483c0aa235761",
+    "2021-06-16/llvm-tools-nightly-x86_64-pc-windows-msvc": "3cdd8e14fa4b31ba16aa6b330165babcca86082397c73262e060b19e4b84d871",
+    "2021-06-16/llvm-tools-nightly-x86_64-unknown-freebsd": "0bfe1a25041d7c74485691106b7ec72ba6c6178bc0fad780a57d8df1c21acd71",
+    "2021-06-16/llvm-tools-nightly-x86_64-unknown-linux-gnu": "7c42d2707ae20d8d8cd4a441c60bbb180ee7bd326fecb884220859dff1b26bc3",
+    "2021-06-16/llvm-tools-nightly-x86_64-unknown-linux-musl": "47728492d7d58cc125db0fe4bb8141e230404fab52fcf898178545de44b341fb",
+    "2021-06-16/rust-nightly-aarch64-apple-darwin": "9883ee9b5b5d4833ea6ad001b0205fecf536db3fc9b19931229922d3af8abf59",
+    "2021-06-16/rust-nightly-aarch64-unknown-linux-gnu": "6540dd65839da5af9106652c361b696b9ac1fe4a14f4ac5801d8d6186b6b031e",
+    "2021-06-16/rust-nightly-aarch64-unknown-linux-musl": "134134199171087947159c446e2c73ef2c5efee20b55cfbe20004c80479b5b29",
+    "2021-06-16/rust-nightly-x86_64-apple-darwin": "5cc5e38ee2ff4c8acc0e57a3bc6e19bbc679ca4f6d4737c137882af4184435d9",
+    "2021-06-16/rust-nightly-x86_64-pc-windows-msvc": "0de02a0fbf7621da7902cdc10a07781a8cebafc71d103ff7e2e3e6fe10c43d8c",
+    "2021-06-16/rust-nightly-x86_64-unknown-freebsd": "8a6245719a44080281713cad744bffd2a7e8ad4578028ffbe1c0999e782c8d66",
+    "2021-06-16/rust-nightly-x86_64-unknown-linux-gnu": "c3af6083060b123102a073028e0109e1585df6ee95003b70d8763f2aa470b3e4",
+    "2021-06-16/rust-nightly-x86_64-unknown-linux-musl": "19f50a5db4699a9dcb67a19cb6b1f559d3e39ce81446d42bad43fa02890cfdde",
+    "2021-06-16/rust-std-nightly-aarch64-apple-darwin": "978397a6ceba7117b89ce5a9822a2dc39b566084950c56954e0163e19afa3bb5",
+    "2021-06-16/rust-std-nightly-aarch64-unknown-linux-gnu": "d6369fa8ba1d649d08b38681234d6aec0f3871e71650ebcfcc59ea7c1bce2ee4",
+    "2021-06-16/rust-std-nightly-aarch64-unknown-linux-musl": "9fb786450e61f6e978efd2bcc238f2cc593b9057e8448feea032b435bf51d8b4",
+    "2021-06-16/rust-std-nightly-wasm32-unknown-unknown": "d53156cf7f97293ea0d2b3b08537b1b2c3b52cc91c5a8bf28e14f69a2bae73be",
+    "2021-06-16/rust-std-nightly-wasm32-wasi": "88dd233aa844d0fb9287576f35d628c617b54da7da04338a14f7abd5aa738a75",
+    "2021-06-16/rust-std-nightly-x86_64-apple-darwin": "60ecd0061a48198e2d890fb736c3059104ac4e88932f7f6b7e1cb59cde7de110",
+    "2021-06-16/rust-std-nightly-x86_64-pc-windows-msvc": "a9b5cd681e66a826fabe48f38630994710f43e3fbcf73c65c59b222a23fd1f4e",
+    "2021-06-16/rust-std-nightly-x86_64-unknown-freebsd": "e5758800722baeaaa0f1b61818564e8a21444dfcbe9602b142d0454218e68d82",
+    "2021-06-16/rust-std-nightly-x86_64-unknown-linux-gnu": "d863737b021c1ae1f1e0bafebf61088232a0c76d5665ce86a6fac8ca95c7bb22",
+    "2021-06-16/rust-std-nightly-x86_64-unknown-linux-musl": "7be512172a022f7011be352e90eb4106344af13e7a4d6b831961fd66f2f83581",
+    "2021-06-16/rustc-nightly-aarch64-apple-darwin": "e3dd00de0ec202c385c3c943dbec7157846314e04108c9496935ea4e273edda8",
+    "2021-06-16/rustc-nightly-aarch64-unknown-linux-gnu": "88b9470cc39c51f1869bcaea2738a71c32baa4f76099dec77d4ce343b486bf0d",
+    "2021-06-16/rustc-nightly-aarch64-unknown-linux-musl": "430e9c095cdba5341e3eb1d9bde03b90fd8dfc54a38c951a8e209b5013fc9e26",
+    "2021-06-16/rustc-nightly-x86_64-apple-darwin": "438e0615f993ddbf518848705c01fbae26f36139e7b48d9df5d1403586966f9d",
+    "2021-06-16/rustc-nightly-x86_64-pc-windows-msvc": "f54e69bf237c882c4d0ee730573e3ebef5eddc4a03730406cf082b43eb4cd008",
+    "2021-06-16/rustc-nightly-x86_64-unknown-freebsd": "6fda58af80d7c597d178b2137adecaf4e94c289f7f55464de0138ce76575987f",
+    "2021-06-16/rustc-nightly-x86_64-unknown-linux-gnu": "44a77db517c05e7b136c8f683e7a9c076fb7c5f15c2d2076a559398a4eeb33ae",
+    "2021-06-16/rustc-nightly-x86_64-unknown-linux-musl": "6eefe98ce50f897fbba0bee21efbc27c76adb108189872a384683bccb4b0aea9",
+    "2021-06-16/rustfmt-nightly-aarch64-apple-darwin": "ba8c2c5a171cb4361667584229fee13b1cfb5a901f00747f13c3b2af4fe72dd9",
+    "2021-06-16/rustfmt-nightly-aarch64-unknown-linux-gnu": "7e11932879ec3164e3042b1544259f93591cb36093f1f0e42324c480da8a58c9",
+    "2021-06-16/rustfmt-nightly-aarch64-unknown-linux-musl": "519e3efc3026780dc0ea3a3020b441a22ce7c497f0f9252aa6a748f2567f1e66",
+    "2021-06-16/rustfmt-nightly-x86_64-apple-darwin": "6e005433e4b5a46347b6ed28371fb97694087c4599447a04a7fe684fa22126a6",
+    "2021-06-16/rustfmt-nightly-x86_64-pc-windows-msvc": "a7606c5ddfca15e066bc844372e81912b256595b8bdbdd3ebea5622cf33bc6c0",
+    "2021-06-16/rustfmt-nightly-x86_64-unknown-freebsd": "239953675a43453195e7f6d7a106a3b65baf57230df0bb0ab19fb6839cf99d32",
+    "2021-06-16/rustfmt-nightly-x86_64-unknown-linux-gnu": "3edba45a2797a3361e575e7aca34284c5ed8154f8849e3da49b59e45317dc65d",
+    "2021-06-16/rustfmt-nightly-x86_64-unknown-linux-musl": "bdeca48139be92c824180e29b790cdb58a4d1e3c15b4c65e9ec93aaae46853aa",
+    "2021-09-08/cargo-nightly-aarch64-apple-darwin": "712aae52f55402ac17ca017dd337ca1aa13f063ecc666fc8c16448f42aa4519d",
+    "2021-09-08/cargo-nightly-aarch64-unknown-linux-gnu": "814ee506cce957c7371bff4961fcb97cc6ee7fc2da4189175be61a4990130824",
+    "2021-09-08/cargo-nightly-aarch64-unknown-linux-musl": "65edd1914dc1f7118f70a722cd7f555bd7e9afc8a1ebb447036ef8948d842742",
+    "2021-09-08/cargo-nightly-x86_64-apple-darwin": "2c539e3a02521842316202cabd37ac580e5d95ee48531435e49628d34217a8cb",
+    "2021-09-08/cargo-nightly-x86_64-pc-windows-msvc": "64c3ab2850c4039c58288cbc402243914eee40d35218665e6a02c8b45efe7704",
+    "2021-09-08/cargo-nightly-x86_64-unknown-freebsd": "c119dd05ee04dc1a0bb414f30036cce9dfb0456eb974bc991acc51122528dd7a",
+    "2021-09-08/cargo-nightly-x86_64-unknown-linux-gnu": "0382a83f1a93228e8fc2c68e396032f61bb431a73aecee75d461b2008c68a33f",
+    "2021-09-08/cargo-nightly-x86_64-unknown-linux-musl": "bfb2a9ea032c591f1c9c36cd2590427c684ebc95b573d919d477b6bd57d5bd37",
+    "2021-09-08/clippy-nightly-aarch64-apple-darwin": "7dade8377af304261199dadf7126afe0e5e50173a89e805567f9d833be59c37c",
+    "2021-09-08/clippy-nightly-aarch64-unknown-linux-gnu": "e36dce42b32982a550a0a575fe827e16e2ba6a53fc850a99f55d8319031625a5",
+    "2021-09-08/clippy-nightly-aarch64-unknown-linux-musl": "abce5645da1c5eeaa193d986f76531e5a3031210e3d94b66d32deba6f15943f6",
+    "2021-09-08/clippy-nightly-x86_64-apple-darwin": "5064e135a17afa8540b6073fda18f686c5bc6903e800ce2f508cf33f74b5b701",
+    "2021-09-08/clippy-nightly-x86_64-pc-windows-msvc": "b7a6dda0b9da65fd964c01ddf16a7b5a309673ad50095bd2c6efe4f62371a075",
+    "2021-09-08/clippy-nightly-x86_64-unknown-freebsd": "8846077e6bd3f96b87b0f341566d51108e4835f23c639e3d95fdb58d31d12033",
+    "2021-09-08/clippy-nightly-x86_64-unknown-linux-gnu": "577ba7ef53a84c296ef1244200af68523708e2ec0884f7e2f7978dae320cb661",
+    "2021-09-08/clippy-nightly-x86_64-unknown-linux-musl": "28365e89efffcd0cbbb7da8d922ebe5c07b2f991fef2c1d845f9f7cdbb014d45",
+    "2021-09-08/llvm-tools-nightly-aarch64-apple-darwin": "dbffc97784c96ba75d6da460d965bd705c7bee737f1d73a0bccf815cc046260a",
+    "2021-09-08/llvm-tools-nightly-aarch64-unknown-linux-gnu": "bc789aa0b012259baa8b5540aee96f1074d9ad6368a5031b556093da61fcd8d7",
+    "2021-09-08/llvm-tools-nightly-aarch64-unknown-linux-musl": "ed3019654dec2aa14233b9fe1a6c934d913acfd798725591ff02d97e10504be6",
+    "2021-09-08/llvm-tools-nightly-x86_64-apple-darwin": "b419d08a367fe4366202106161fa1ccc4dfead9639e582b36c71c3405dc58e8f",
+    "2021-09-08/llvm-tools-nightly-x86_64-pc-windows-msvc": "213cfa58059ba87e650acb240f6b1f9ed6948687fe12a236b16d0abe3e293fbe",
+    "2021-09-08/llvm-tools-nightly-x86_64-unknown-freebsd": "cef580a6e8efcea89bbf40de422e04c36546462ef9e90727da7e339bc9acb83c",
+    "2021-09-08/llvm-tools-nightly-x86_64-unknown-linux-gnu": "4a5ff52134c2dab1746c9d3d84bac92b5ea4fbbb4067c83ae20524eaf060e6db",
+    "2021-09-08/llvm-tools-nightly-x86_64-unknown-linux-musl": "f20f89d4f5c49e57c950770b9b83581534b9f64187f718b8392ff58559b72de0",
+    "2021-09-08/rust-nightly-aarch64-apple-darwin": "67f875cbaeb23dd0aabcedd0c80809cbe9d0799f6316a0b37353d16921f3319e",
+    "2021-09-08/rust-nightly-aarch64-unknown-linux-gnu": "e27d7a5cdb7076674d885ce034ae243fa77f7d1210c83d52c8f8e4c4be86d204",
+    "2021-09-08/rust-nightly-aarch64-unknown-linux-musl": "c4b9090ec6793d96443ba51b0e531d99e7dfe715e2a506e28aa8e070c4811050",
+    "2021-09-08/rust-nightly-x86_64-apple-darwin": "50e5552ae8c20b056b122d2bbc45030f10772498b3bf88b6c539c9bab9e4555c",
+    "2021-09-08/rust-nightly-x86_64-pc-windows-msvc": "2ba241a6982360ffabbc383f91a642dc42c59770253041d8634255543a84d5d3",
+    "2021-09-08/rust-nightly-x86_64-unknown-freebsd": "da6ceabe8dbbd1f92e0dc77a4a98ff1745bb21ea714d9f4eac090626d5a480d0",
+    "2021-09-08/rust-nightly-x86_64-unknown-linux-gnu": "ea4960a18a13815736fcfa33886fa9de8f07ee758339050ce676ef81e9cc0f0d",
+    "2021-09-08/rust-nightly-x86_64-unknown-linux-musl": "acdbb72ee7e579940df739755ac478e3a386431aa606a9ab08ad1c870a24794b",
+    "2021-09-08/rust-std-nightly-aarch64-apple-darwin": "8a08b1862d2e69d249d67fb5669983ae961bd07b9bfc80585ef84269380a317f",
+    "2021-09-08/rust-std-nightly-aarch64-unknown-linux-gnu": "0f2fafb6f4c4693380b3e8eaf4a08729b511cdb1f89c4976c2944b4f87e48b66",
+    "2021-09-08/rust-std-nightly-aarch64-unknown-linux-musl": "4b2c1b78637bb0ddb7f5e2ae16119f84e00f16e874955c34dd3684e67344ac99",
+    "2021-09-08/rust-std-nightly-wasm32-unknown-unknown": "ef19646fb38abfde637fbd619c4cc4b52826fce09074f427d3cdd7d5bbf89167",
+    "2021-09-08/rust-std-nightly-wasm32-wasi": "df7cf483b11358850a2f0f9d6816b8ebcf3813ff4c0cc75cc99171200b2f866a",
+    "2021-09-08/rust-std-nightly-x86_64-apple-darwin": "4d13a115d70efc84daa181bf7927b4531c5e40cfc1df8a99c04c9ebb4010b829",
+    "2021-09-08/rust-std-nightly-x86_64-pc-windows-msvc": "0c93f9734b776bf7c2e150fedc2811db108e732a4f3328aedb038969b435c071",
+    "2021-09-08/rust-std-nightly-x86_64-unknown-freebsd": "64ff9746ede66362f44aa5de62541a85a196e639a2cfb5d60be038579ddcd367",
+    "2021-09-08/rust-std-nightly-x86_64-unknown-linux-gnu": "b6d1ff428b1c0591ea7375f6ae3421630d4b6da7e8cb6bad071284b5d563abe8",
+    "2021-09-08/rust-std-nightly-x86_64-unknown-linux-musl": "1cb7c1f28e4fa5096aaea77e56006a1cee69b77c5fcb1fae993a961942ea16d0",
+    "2021-09-08/rustc-nightly-aarch64-apple-darwin": "4de0dde4a4499074c9c4ca3a9617c89376ccbc21429ce2af94147570844f5436",
+    "2021-09-08/rustc-nightly-aarch64-unknown-linux-gnu": "a34ca09afb230c0852b1765f4477ff1135f66cb4c41fe88ca79901c3adf30aca",
+    "2021-09-08/rustc-nightly-aarch64-unknown-linux-musl": "9594f62bd1e209725302318f372ea2c28cbd83ec2b29c60e5db933f60674b447",
+    "2021-09-08/rustc-nightly-x86_64-apple-darwin": "1a7eccf24dd1baecbe07c2999c917e54e7f213496a2ed542fc8ba5afbb43d1f2",
+    "2021-09-08/rustc-nightly-x86_64-pc-windows-msvc": "15667c4fe1d810b3b1979c19d1def41dc5484f7444517c4277aec2154404face",
+    "2021-09-08/rustc-nightly-x86_64-unknown-freebsd": "13b46879f9eb1a5c467458ab1eb3a65d295d9834f3fec42f0ad4a273d9fde926",
+    "2021-09-08/rustc-nightly-x86_64-unknown-linux-gnu": "73891cf0b7eb252b6b8486ddaad91f7ce4b18950befe7853bc3d20d38e5ae069",
+    "2021-09-08/rustc-nightly-x86_64-unknown-linux-musl": "ba94c257e93dab13beaf0a78168de64295ee0178fe76a8be10e18c5fb5d7c5fb",
+    "2021-09-08/rustfmt-nightly-aarch64-apple-darwin": "691922fb32f3da37532bb9be974ad1717af521ec2b71bca4bbb5e57f3c4cc3fa",
+    "2021-09-08/rustfmt-nightly-aarch64-unknown-linux-gnu": "98b2eaf259a1bfdc70e40a52e891920dec7fc6132ad8d2420f91655c793ea340",
+    "2021-09-08/rustfmt-nightly-aarch64-unknown-linux-musl": "a4df0726fba466a5180471d3e63735c2b5ee9794e9f42026b1e8ae404dd43ab6",
+    "2021-09-08/rustfmt-nightly-x86_64-apple-darwin": "20de8ad3aa7507dd9657c4a4b959c38cc7f732a87bb757183033f78a96288e45",
+    "2021-09-08/rustfmt-nightly-x86_64-pc-windows-msvc": "0cc0f10763b73c5e4c8bdcd15a563d7e9d705b192ed6e8edc50dd6a71b874761",
+    "2021-09-08/rustfmt-nightly-x86_64-unknown-freebsd": "e1c28472a81312560ca36719f0b61b7212a07d63e85d745f97cd8e3b9ea8f191",
+    "2021-09-08/rustfmt-nightly-x86_64-unknown-linux-gnu": "a7d579672b94978e8427584f7e9d2b6534f320719252db46fc6ee85082d646ff",
+    "2021-09-08/rustfmt-nightly-x86_64-unknown-linux-musl": "fba0e7bc1401b830223b5207b63808e28403f48d1591c7d47c1681519c1883f7",
+    "2021-10-21/cargo-nightly-aarch64-apple-darwin": "6eba28dffca35b3b8809c0f56e93931ecf75b539d3ca0f048607047b2f3a9588",
+    "2021-10-21/cargo-nightly-aarch64-unknown-linux-gnu": "c91ab0b98bdb80b9136a06e8d6fff33641fad1c9a005559c976db57a5939bb90",
+    "2021-10-21/cargo-nightly-aarch64-unknown-linux-musl": "f0705d665f0721e64673ea8f282980e968fa1186793b7d6530415e0bd05e1711",
+    "2021-10-21/cargo-nightly-x86_64-apple-darwin": "84d04dd97de2e288d7f449006fd81a930ab1d9fddc20299c9aa8f9bcf1b5cbcd",
+    "2021-10-21/cargo-nightly-x86_64-pc-windows-msvc": "2bdd1823caaf95e2bbf8942c35daeb9aed2bf69534bfdb18f2aa8d1e32a0741e",
+    "2021-10-21/cargo-nightly-x86_64-unknown-freebsd": "e578efd5bb719ef96435e2e24969f968ddc00ec1515c86a7fbd01a650976e028",
+    "2021-10-21/cargo-nightly-x86_64-unknown-linux-gnu": "7fc7f3649de6d8aea2304f286d2d1e5ef279b38d88d8fcbb8b81b1a355201273",
+    "2021-10-21/cargo-nightly-x86_64-unknown-linux-musl": "b022b8341aae8c7d698d44a9f69439569385fb6a3c6e5783cf68853513023c10",
+    "2021-10-21/clippy-nightly-aarch64-apple-darwin": "ee11bef6780c3c326ba39c4fb2de53c7b82f3461ad50131811919067bdbc6d21",
+    "2021-10-21/clippy-nightly-aarch64-unknown-linux-gnu": "3e5b3866242c1c3405ab102c205d07bb633fe1884a0b1ef72e1deada91143fa4",
+    "2021-10-21/clippy-nightly-aarch64-unknown-linux-musl": "8666c8dfd127d69531f723210e23675fd372bf72c2c4ea3f853f00e6784c17bc",
+    "2021-10-21/clippy-nightly-x86_64-apple-darwin": "0bfd130526f021f8ee9c003895af276c9978f9da7a03e50d0efe59a73bcda1e2",
+    "2021-10-21/clippy-nightly-x86_64-pc-windows-msvc": "713491e5f7d1a6bb8bfe5433706515fd639b359d5a589ff3ed98a23c187a875f",
+    "2021-10-21/clippy-nightly-x86_64-unknown-freebsd": "6db6b98be1093fdf97a11cec2a87f30c27a10c6e7e96652f7b758f2d7428832b",
+    "2021-10-21/clippy-nightly-x86_64-unknown-linux-gnu": "8deb9bc3831bb90cd49b9ec8763c5a98349b5b47b6622634e64d8d58a2bb33c0",
+    "2021-10-21/clippy-nightly-x86_64-unknown-linux-musl": "effdaf877422d4700dc2ebba543c4186a5e281336c8f415c20482e75abc7f602",
+    "2021-10-21/llvm-tools-nightly-aarch64-apple-darwin": "d6a2bb9d9c097fd3ff15477a95edb77aa6efdae12c5964398e232339b15a955e",
+    "2021-10-21/llvm-tools-nightly-aarch64-unknown-linux-gnu": "8c9d5b9fe646fb39448addf7ee370cbba2c2a229189d38443b17f369dac2f405",
+    "2021-10-21/llvm-tools-nightly-aarch64-unknown-linux-musl": "1dfa08db634e1276d48aa26e5dbc50bf2fde3f2f8ae52dbe5f8ec8fc80bacb76",
+    "2021-10-21/llvm-tools-nightly-x86_64-apple-darwin": "b2331bc949012a35da7c3caccf87dc41f176ffec3c2101f5f2dcc9f83d733483",
+    "2021-10-21/llvm-tools-nightly-x86_64-pc-windows-msvc": "d6aa710e9cb1a8c5913acf2addd40a261f68063e9983441d4396f4443657e467",
+    "2021-10-21/llvm-tools-nightly-x86_64-unknown-freebsd": "85a642dbccf6f8637a5a1ec63e92d61040a9c59319ac1f9e713f5b891b26793b",
+    "2021-10-21/llvm-tools-nightly-x86_64-unknown-linux-gnu": "fa9532d8bd4cfd19626c700601cb73011b00cdd4325c5f5417004a3124d277e1",
+    "2021-10-21/llvm-tools-nightly-x86_64-unknown-linux-musl": "ae10630bd5117da9f5fa5eea27b5624ad864d4d47a291a1f77ca5508c9691762",
+    "2021-10-21/rust-nightly-aarch64-apple-darwin": "5716c620dc210d2575b95f43e7dfe5100f2a8c21651fde66217a506bab96d640",
+    "2021-10-21/rust-nightly-aarch64-unknown-linux-gnu": "b375f0cc8e83dea3c8a32c843492930460736c8bdb6ca3db93e7fa563f312b20",
+    "2021-10-21/rust-nightly-aarch64-unknown-linux-musl": "ddc46ab912d69fe56cd68a74123a08404ce5f0f74551d4433e8632b45114b0dd",
+    "2021-10-21/rust-nightly-x86_64-apple-darwin": "75b66db55f4b0df4592651fc573e4251fa45b3b48b2fdff5a86186f138ff081b",
+    "2021-10-21/rust-nightly-x86_64-pc-windows-msvc": "b15a584bfb4a55719a91b33239664a8eeb55e7f7580e53d947c78bf95b8a034e",
+    "2021-10-21/rust-nightly-x86_64-unknown-freebsd": "74676a2604ca5032307b0dc7865d1833ffde41440d649fd8e083b39e291dbb24",
+    "2021-10-21/rust-nightly-x86_64-unknown-linux-gnu": "778d604ebb1407b59f3d331d986b2d5ead609b2cfe5db6f0ba098375eaee021f",
+    "2021-10-21/rust-nightly-x86_64-unknown-linux-musl": "e7b285da594860356b12d61a5cd6da54e3bffef52b1b5a4f8ffeb1fa86736343",
+    "2021-10-21/rust-std-nightly-aarch64-apple-darwin": "28e2aac0c80e4e62874fe4a97fbeea9dc4482e74964eb1f4e8a83d7531be1a58",
+    "2021-10-21/rust-std-nightly-aarch64-unknown-linux-gnu": "c810f89068c71626ba3326b26cc24d017a76f060eadcd84ad0152b66031bd9f6",
+    "2021-10-21/rust-std-nightly-aarch64-unknown-linux-musl": "212d4f2928e14280bd2ed7a5f35e1a731521da58823f186a685db53711d5db8b",
+    "2021-10-21/rust-std-nightly-wasm32-unknown-unknown": "3db3ab740447206c71e303a9098a0eac2fa14117e4d6e437308239e0d469cb3b",
+    "2021-10-21/rust-std-nightly-wasm32-wasi": "be3ccf5a00e7698b152df33d31406a533ef3fae545d4912e6c3c85b40afd4e25",
+    "2021-10-21/rust-std-nightly-x86_64-apple-darwin": "73a686b2577994bf641a6422338a0cddf4250058df74ccc7540bc6026c53bb3b",
+    "2021-10-21/rust-std-nightly-x86_64-pc-windows-msvc": "1d7f65a9b63a1756d5915c8305930eac747dce5da8583af00f9cff8b803a33ad",
+    "2021-10-21/rust-std-nightly-x86_64-unknown-freebsd": "2903783f094fb121a9171d999aa0d73a255fb5617e4cdad5d8470183758bbb23",
+    "2021-10-21/rust-std-nightly-x86_64-unknown-linux-gnu": "ea390777b60ccd6861e7d163cdf0c19be0b19944039f1b52283120b598f56258",
+    "2021-10-21/rust-std-nightly-x86_64-unknown-linux-musl": "182d763bc6e727f98673ab6ed9d707841e2ea8dd4571bab4f289afb5006b396a",
+    "2021-10-21/rustc-nightly-aarch64-apple-darwin": "1b6a6bf8652751f5123cb7741466cec2164302f3306da92241b2b64103398236",
+    "2021-10-21/rustc-nightly-aarch64-unknown-linux-gnu": "60510d5d77b2d55e3b676bc0e478455452133f3f5dc3c173ba3d251c6b780ec3",
+    "2021-10-21/rustc-nightly-aarch64-unknown-linux-musl": "eef17c07cd783c2a3556785245280b3e0a56290ae4620ce324dffd88caff9785",
+    "2021-10-21/rustc-nightly-x86_64-apple-darwin": "9218bbf8d37c9c6a015abade1129a3b5d37453f144b2999b2f6b569044982ac7",
+    "2021-10-21/rustc-nightly-x86_64-pc-windows-msvc": "62e82a4283298165a0a7d656494d9f6da83cf44e098c337cfd7032acf96d0ebb",
+    "2021-10-21/rustc-nightly-x86_64-unknown-freebsd": "af6c9b69129a4a81fd79481f16f9feb1d4f726859b8d888cffc6fa8231a67c10",
+    "2021-10-21/rustc-nightly-x86_64-unknown-linux-gnu": "0bf65939240f9acbdb08cc4d22b9fb14357d29ee36f4bfc11d4ecc87f07b01db",
+    "2021-10-21/rustc-nightly-x86_64-unknown-linux-musl": "1a9bb9f7cbb5465de5976e75a730dc88a4081ded1f9fb54af1fa514a15b88732",
+    "2021-10-21/rustfmt-nightly-aarch64-apple-darwin": "51d764ca7e1c60fed329b1cbbd2a6a56e5b41f7b728a170745f8a4b4bad10b52",
+    "2021-10-21/rustfmt-nightly-aarch64-unknown-linux-gnu": "2ff4e25789d019047ff451faaf44a67cd155b4c0ec6834487da6cea950bdc2db",
+    "2021-10-21/rustfmt-nightly-aarch64-unknown-linux-musl": "ad433ebb84627c18d4c8b13623f52c46b23f628ef9a3b12e712381c504324960",
+    "2021-10-21/rustfmt-nightly-x86_64-apple-darwin": "589c1412db27f90407147ce3acad3afdb1769d77c1f31156ad6101c317f28490",
+    "2021-10-21/rustfmt-nightly-x86_64-pc-windows-msvc": "49b0163001fd7dd7395f89b408c9909c5b33c4f3147902ec2f77e567bb9d6b9a",
+    "2021-10-21/rustfmt-nightly-x86_64-unknown-freebsd": "d76aca59bb56c6f2e01ab5da9461e058814ba2fed6ebc3abb6bf55ee44a241cf",
+    "2021-10-21/rustfmt-nightly-x86_64-unknown-linux-gnu": "d53c942dc0628ec0214f0eff51ebdd8c70f2bff1293909c908e063c9153144eb",
+    "2021-10-21/rustfmt-nightly-x86_64-unknown-linux-musl": "21b3db961750e8a6ff83d2773e0feb86292fd92fbcda9f3362976b04b9069254",
+    "2021-11-07/cargo-nightly-aarch64-apple-darwin": "1947ba0d6b97e097bad279bbbf891d7a65d3b1611280dd88e82fcdb9f832cb3f",
+    "2021-11-07/cargo-nightly-aarch64-unknown-linux-gnu": "fe70a3e01abd01738c51479a7bc834392005cce661969088dac220f1b5fce31e",
+    "2021-11-07/cargo-nightly-aarch64-unknown-linux-musl": "987df6c4597a26c1a9bc0f195312cc96dcf2fe1f3651e91bea72a34f6dbe4d82",
+    "2021-11-07/cargo-nightly-x86_64-apple-darwin": "968790a3027da539c57caf194b8feafc9b01d3482566d58f2e012e8d00c28265",
+    "2021-11-07/cargo-nightly-x86_64-pc-windows-msvc": "e56ce94434929c1a4eb2bdfdcfb19e4194ff177c1d5934403deadd3db4304f91",
+    "2021-11-07/cargo-nightly-x86_64-unknown-freebsd": "51b2935810f845a9c85c51344488fe403ce13d49196135318373888726752339",
+    "2021-11-07/cargo-nightly-x86_64-unknown-linux-gnu": "66f027e3245c2fb444a272c9429c6b6334da8afe1ed87ac5ecc68f357cd37c82",
+    "2021-11-07/cargo-nightly-x86_64-unknown-linux-musl": "f6b4e44c2abc28281da5e03c0a957b8b54e22de34f6cab94894efbace7343c02",
+    "2021-11-07/clippy-nightly-aarch64-apple-darwin": "f16cae78cd8cadb8389817489283a572021a5f944e80c5c328ee32a83fb869c7",
+    "2021-11-07/clippy-nightly-aarch64-unknown-linux-gnu": "b0cf7f65fb5a903e62551e49b9341690b4f800552b34a4709ab8630a5cbdb71b",
+    "2021-11-07/clippy-nightly-aarch64-unknown-linux-musl": "b320ed68f8af98cd4c857ab7e3b2e3bed38f580ed6b72cc0f71e90e8dbbfb72d",
+    "2021-11-07/clippy-nightly-x86_64-apple-darwin": "40f91067724c983bf6061a5db4ba90bd620718f564648287ec52b348d76d012c",
+    "2021-11-07/clippy-nightly-x86_64-pc-windows-msvc": "1279ba3f78951e5f2180f3f07fcdbf4eb561ba5cddf84afdf53ebdd4b8ca2e24",
+    "2021-11-07/clippy-nightly-x86_64-unknown-freebsd": "3aeedabc9dcf54048f59a8ba9e695495ea3f570b88df98ef03c8d1247fddeaf8",
+    "2021-11-07/clippy-nightly-x86_64-unknown-linux-gnu": "567b3a83390c893077b540cd07f4798d8d287e30025f437ff4e21609b1a773c1",
+    "2021-11-07/clippy-nightly-x86_64-unknown-linux-musl": "a97bddc05146f2c55016af4cc53cd06786a01eb111dfe139bc421eff1c54c645",
+    "2021-11-07/llvm-tools-nightly-aarch64-apple-darwin": "f3c5c93432ac2c7397ba5bf598f36a9e05ccec1ba8646e7127dde13741e91e78",
+    "2021-11-07/llvm-tools-nightly-aarch64-unknown-linux-gnu": "efc96c6a6d7cb0cbe254f1486c5b9678078aca950bdadfc36d8218fd0cd739fb",
+    "2021-11-07/llvm-tools-nightly-aarch64-unknown-linux-musl": "f760aeb71cab8abc582eed5766433a7851be2da80d20b75dbcae5df0d3c3be91",
+    "2021-11-07/llvm-tools-nightly-x86_64-apple-darwin": "3b95d04628e75c2ab43298db610e519fe4c00057757bce67461264e2479d265e",
+    "2021-11-07/llvm-tools-nightly-x86_64-pc-windows-msvc": "26a88a8d0e0b2fd9336b85e8a8cc7aa0aef72efca48c0acabf40a5f9f9b9902e",
+    "2021-11-07/llvm-tools-nightly-x86_64-unknown-freebsd": "064b8fef9689bb51cc6358e3239920117aa518e9d375be48d3d7e17ce4b7d2df",
+    "2021-11-07/llvm-tools-nightly-x86_64-unknown-linux-gnu": "a72f3f2034921baa4e8d2af412532df45d39d163ee6af77c1ed5da3be32efccd",
+    "2021-11-07/llvm-tools-nightly-x86_64-unknown-linux-musl": "da704644570b177093eb13486b3f34a6aa7c8b93fa565395eb15ad29bc75fb15",
+    "2021-11-07/rust-nightly-aarch64-apple-darwin": "ec27e6e751bf24916e53e3d601bf4e406e624f4ed894aeddef6b418622b41316",
+    "2021-11-07/rust-nightly-aarch64-unknown-linux-gnu": "cdafea25f36d618d754ddba007ffa0cc0e52df60c160187f68f7d41a91efaa12",
+    "2021-11-07/rust-nightly-aarch64-unknown-linux-musl": "b204d0979da8fa81a5be832868df4ccf9031e9582d2a9720bd17be5af845c055",
+    "2021-11-07/rust-nightly-x86_64-apple-darwin": "fca7b8c128fc2c0b8834d06f6ebf78e4d2030be83a87a08f2f9f5247d2be8470",
+    "2021-11-07/rust-nightly-x86_64-pc-windows-msvc": "bf441a201b48d61a5908952367f830fea0642993d518972fd3acff62b6c1e321",
+    "2021-11-07/rust-nightly-x86_64-unknown-freebsd": "bd0791a44cd3c8f2274b42b9206016ac948cac97b642f0303c0f19e0fffe6089",
+    "2021-11-07/rust-nightly-x86_64-unknown-linux-gnu": "ece5f02e4c1cbaf6801fab787d834166aee7676f7c3b2272ff9810d6d541af27",
+    "2021-11-07/rust-nightly-x86_64-unknown-linux-musl": "926a2b44e0c2f093e62e696b6e53e3b5a9d7882e8c426cfdb364a3e2a2541ebf",
+    "2021-11-07/rust-std-nightly-aarch64-apple-darwin": "478dd2f878e791185e565f9a6a2ae0e7a35c472cce873e50bd6b9cf56b364a38",
+    "2021-11-07/rust-std-nightly-aarch64-unknown-linux-gnu": "31e933401b920a16b797f8ebd3f7cdac43647db5b266f8e812a847f34f167b66",
+    "2021-11-07/rust-std-nightly-aarch64-unknown-linux-musl": "b27f126391825d7db36ccfb688ac3c1d3ded91b9b26446dd1da7ece05347f96d",
+    "2021-11-07/rust-std-nightly-wasm32-unknown-unknown": "da22f32ed22a44d1cf478b52e062494ae063cc3ccd06b12964d6000cbae54186",
+    "2021-11-07/rust-std-nightly-wasm32-wasi": "02fa9f517dea1f31eaa6366c3de5bea2a6c3c09f16758e7a70518727d77191d2",
+    "2021-11-07/rust-std-nightly-x86_64-apple-darwin": "983aa9ada64afb54453b39e572f5d622b2f390dcbeef1002aac1a5d11a50b3a8",
+    "2021-11-07/rust-std-nightly-x86_64-pc-windows-msvc": "408884156e55fe210880e7ee7612a5bbbb2300e4dc4d1ee0cd3726a1225343ca",
+    "2021-11-07/rust-std-nightly-x86_64-unknown-freebsd": "c42b5c495e216764f56e538f0cd54fb6cdf193cd3348a7f37b157f27f440ea43",
+    "2021-11-07/rust-std-nightly-x86_64-unknown-linux-gnu": "218743da51034586ed84ad43f95d95a38805403f0e31faaf247eedba883fa8b5",
+    "2021-11-07/rust-std-nightly-x86_64-unknown-linux-musl": "f5733b29a9c1102355cde885cebf5da42b738632e7dc5919e246c34551126c50",
+    "2021-11-07/rustc-nightly-aarch64-apple-darwin": "ccfd72ed6a189c490d22ea91e53ba7d217db123b6c4015de94ac88973a4f031c",
+    "2021-11-07/rustc-nightly-aarch64-unknown-linux-gnu": "3f5a445397f8a7dece4195b7c181398b6d7c06480bc59ce92058c97f68172353",
+    "2021-11-07/rustc-nightly-aarch64-unknown-linux-musl": "5588596a3ef4bd938802349faf64159fb661f04717fef2d08acfc50d35de4673",
+    "2021-11-07/rustc-nightly-x86_64-apple-darwin": "c3df9cac3419633ae1e9b6a41183a413a3a722a72124394d441d5c914aa9f91d",
+    "2021-11-07/rustc-nightly-x86_64-pc-windows-msvc": "e218ed52bcd57b25a0eeb8a9be4fe954ea226f785940409cc6fc378ad8f25876",
+    "2021-11-07/rustc-nightly-x86_64-unknown-freebsd": "c5f2cc78f5f59179e0fb3770e58eacc44eddcb0c3b2c143b8681776b4caead88",
+    "2021-11-07/rustc-nightly-x86_64-unknown-linux-gnu": "e7e6dbc8291d283a890c994ec9507dfce25aa93a47b2cc213f845b3bedcd2002",
+    "2021-11-07/rustc-nightly-x86_64-unknown-linux-musl": "95fcbd60d484725002c1d20134160201417cc6715ba4e320fa30f95afd95b4e0",
+    "2021-11-07/rustfmt-nightly-aarch64-apple-darwin": "3493f540161825feb81d022bfb6f84f2040f5ad014640e9bfd1a4b93902113c4",
+    "2021-11-07/rustfmt-nightly-aarch64-unknown-linux-gnu": "58291d3b3045b3c2f156d7547db3d5c117840663a6d10425580fe2936c1f7f9e",
+    "2021-11-07/rustfmt-nightly-aarch64-unknown-linux-musl": "85178f75658b69291bedfae0d7c27505f7b0aa0fe53de3922d2f3f671d601e13",
+    "2021-11-07/rustfmt-nightly-x86_64-apple-darwin": "71bcbd9b0e8417e8cbcece46701a3e023eaa596377bfa66507fad0ad383cfd46",
+    "2021-11-07/rustfmt-nightly-x86_64-pc-windows-msvc": "c082bc7eb8d04e4d7025e23b443b14aecc5d504e3de21c1c110c3e04d05d71f0",
+    "2021-11-07/rustfmt-nightly-x86_64-unknown-freebsd": "21815c052a39c5c5d361bbb473a2c36125eb657598359f6b343e352c278c0543",
+    "2021-11-07/rustfmt-nightly-x86_64-unknown-linux-gnu": "102e7e2300fd6dba8aaee468b887ea7fdc43f39f012db2815040586959f6aa36",
+    "2021-11-07/rustfmt-nightly-x86_64-unknown-linux-musl": "8ac20334b400e0a6e4b487e3536f7236f9238a45d63f490baeda7c47fac72504",
+    "2021-12-01/cargo-nightly-aarch64-apple-darwin": "424a002ad3d9b2974aebf3eea8400081e3aa66b1b4aea0e8b12534b0d6857bde",
+    "2021-12-01/cargo-nightly-aarch64-unknown-linux-gnu": "56ef3a6f98e063b7297f5a92ac9aa20fd8d1a235a4879a10c3b8a0ebe2e57245",
+    "2021-12-01/cargo-nightly-aarch64-unknown-linux-musl": "71d08d9ac3da4c628e91b0e9e0b34ad55d2f4904953003ea96d2b016837c5f1f",
+    "2021-12-01/cargo-nightly-x86_64-apple-darwin": "4d12c1d9034cf759c15d30d768a3010504621f5ccfc22026bf6591afc16bc780",
+    "2021-12-01/cargo-nightly-x86_64-pc-windows-msvc": "06b258fd6c10aa97bcfdfaa9e6d728b7024f1ca9bb4b69978ee433710e1235b6",
+    "2021-12-01/cargo-nightly-x86_64-unknown-freebsd": "924f3f0b15d8109261c4a28050e64eaed0d5f2dba9865920d7a3f94f613d2517",
+    "2021-12-01/cargo-nightly-x86_64-unknown-linux-gnu": "0757e9d7faa9b601b35294a44b6224087f6df384e157f8a80a8bd7f609532987",
+    "2021-12-01/cargo-nightly-x86_64-unknown-linux-musl": "bf5bcfbe47ccc49d830623a57b723a3c7436637c36d84b53f597d85ee1132cba",
+    "2021-12-01/clippy-nightly-aarch64-apple-darwin": "bcfd9191c6cc2b779ddb5c5bc5ceaf3fb8efa700123c175a0944662809357efa",
+    "2021-12-01/clippy-nightly-aarch64-unknown-linux-gnu": "4903c94d97700b9ad70689fbaaaa939a2f37d4736cf87bcf900ae5e909a6917a",
+    "2021-12-01/clippy-nightly-aarch64-unknown-linux-musl": "7453115f2b361db826c5a6def06bf9531876cdca77f9b3a8339c0446d0e88c8a",
+    "2021-12-01/clippy-nightly-x86_64-apple-darwin": "b9f69c5e50fda9d22d029f51e181971f9d7acdd81607fcbbec8da87ee2678acc",
+    "2021-12-01/clippy-nightly-x86_64-pc-windows-msvc": "fe56e5385392eb7109d2450eeea78a744a830f0df4bc08cef62ed70530c6f7ff",
+    "2021-12-01/clippy-nightly-x86_64-unknown-freebsd": "2fa59d32937de93d322a0c3458c6f732950bae75f7487ce10516b2a2299dba3a",
+    "2021-12-01/clippy-nightly-x86_64-unknown-linux-gnu": "238167df07be8b65f325d7409d3822c42832db3afa289fd303619acfa62ebd4d",
+    "2021-12-01/clippy-nightly-x86_64-unknown-linux-musl": "12cc9629b9fcb7760d38b38ddb19f6ab173994fa19bae9ea0ef10e560b36e9d6",
+    "2021-12-01/llvm-tools-nightly-aarch64-apple-darwin": "3889ad569be62d99cd0f1de0ccf404a7176c862ef6e001130438d86067aeb266",
+    "2021-12-01/llvm-tools-nightly-aarch64-unknown-linux-gnu": "d0e4f1e40c769376728fe5bbe1f3e254959c33513a18dea1e111cd2e2d2fe8c0",
+    "2021-12-01/llvm-tools-nightly-aarch64-unknown-linux-musl": "2960b9000f0c32deb12096e99ae26af4f85d2313c0227a95fae89637a10850b7",
+    "2021-12-01/llvm-tools-nightly-x86_64-apple-darwin": "1ac4f401421e7bc34a5c17aa5f8a0802f5e1bdb9341d4969ff058ae387e95eb4",
+    "2021-12-01/llvm-tools-nightly-x86_64-pc-windows-msvc": "f7bc73ef6cc909ad1a20a9c91386ebb67d0dd3b300698ed50a3fe314921f636c",
+    "2021-12-01/llvm-tools-nightly-x86_64-unknown-freebsd": "9755dd8b446a7fe327b28e699b43c64a8088e87b7f501869d8bc77c7bd17e80a",
+    "2021-12-01/llvm-tools-nightly-x86_64-unknown-linux-gnu": "845265609040d3a620e731a8d1f0f59f231ab6699ffd6132411437aa9b3c3060",
+    "2021-12-01/llvm-tools-nightly-x86_64-unknown-linux-musl": "68660d1226628edcbe80baeacc075d8d4f9c6ea87bb22fc55b6727e6807e5d6d",
+    "2021-12-01/rust-nightly-aarch64-apple-darwin": "c304a7a154b8bf44ff7a338996f1dd249678871bf1d24977e8763912197f89aa",
+    "2021-12-01/rust-nightly-aarch64-unknown-linux-gnu": "b0b3dbde13f8cea3086896efe8402b87cf281260ceb4bf8d3f1bfd1216a309d9",
+    "2021-12-01/rust-nightly-aarch64-unknown-linux-musl": "3e210d5da0384b90e90933683ac19ab1d2439c6b920db8c24e15faba484c86e9",
+    "2021-12-01/rust-nightly-x86_64-apple-darwin": "720d6058352322f1d59683236f0d5092d90ed64ed3f41cee80aa55d3d5a8c7ca",
+    "2021-12-01/rust-nightly-x86_64-pc-windows-msvc": "e4e42a29016982376a9e178cc83874480bd300e5fc6262ed3a1034ec0b80349f",
+    "2021-12-01/rust-nightly-x86_64-unknown-freebsd": "a85e08ec1a52a6bd496400de638bb2e57c7f1192c740e03a776a11e1e892620e",
+    "2021-12-01/rust-nightly-x86_64-unknown-linux-gnu": "ffcb8b45a95221f8d77bb93faf3fd0e2a7f18e6759e631a45295883f996a4d40",
+    "2021-12-01/rust-nightly-x86_64-unknown-linux-musl": "4d98286d2ca36cd348de7a78c8a127b6fec181e1b00fd045be0ad4fa2b466e83",
+    "2021-12-01/rust-std-nightly-aarch64-apple-darwin": "907bd677f494c0858803bcb3c00c1da60b9ec0ff25c71960a896dbf89a7a61a5",
+    "2021-12-01/rust-std-nightly-aarch64-unknown-linux-gnu": "3ae916ceef3364a49c3eb3e936af95aec043cad8cb293fa3f7703846728cd398",
+    "2021-12-01/rust-std-nightly-aarch64-unknown-linux-musl": "71421760124795171964945203719f7dec1924beacdb73b9658d01c8cab37b5c",
+    "2021-12-01/rust-std-nightly-wasm32-unknown-unknown": "e24999e365a8701b8466d2081ec61589b1c4a9333256779b60594688999d2334",
+    "2021-12-01/rust-std-nightly-wasm32-wasi": "5b31eb7ef9c580ebb751f4c41851ef3184261e2fc6c3481567cbb36a816681f1",
+    "2021-12-01/rust-std-nightly-x86_64-apple-darwin": "fc84ac87b089a198731e82a203d38a3a07b72e3f7399b0b47c1d0ec2be576e0d",
+    "2021-12-01/rust-std-nightly-x86_64-pc-windows-msvc": "9b6e945d5a42162b5f3ec792015084e4f349a338605478630b874e9388662300",
+    "2021-12-01/rust-std-nightly-x86_64-unknown-freebsd": "7a03e9faefc1f36d6b6c240371c7db539593cfbed47ca6dc141e3a0c2fc71bd5",
+    "2021-12-01/rust-std-nightly-x86_64-unknown-linux-gnu": "003b3e83e798d635206ca06c919696f2eea7277d9721c8623272fa33059ec2ab",
+    "2021-12-01/rust-std-nightly-x86_64-unknown-linux-musl": "f6c14b5df1fa6341a1b5f4dfd53c2795e2f7c43fc522aac57d055143ebe5e06c",
+    "2021-12-01/rustc-nightly-aarch64-apple-darwin": "ec3af041e4a8aa4bba5d8565502f983f358d9884cce61911e70bb2b12a63f9a5",
+    "2021-12-01/rustc-nightly-aarch64-unknown-linux-gnu": "0f863eb5a00810f140bd6a10ea74e9a2011e852958ac8f8ca50940325864afb4",
+    "2021-12-01/rustc-nightly-aarch64-unknown-linux-musl": "e0432ff13bdc00a36fa1fa20b736a385d6803795855214438d256f0678edbc94",
+    "2021-12-01/rustc-nightly-x86_64-apple-darwin": "6c1557e71cf3aeeb244855c32a7ec9b0297dc66ba57cf17af4e16fd1388f08a7",
+    "2021-12-01/rustc-nightly-x86_64-pc-windows-msvc": "41aebe787fb1a5699f0dd224e9e47270133fa4c971faa97cba2ac609c24828f6",
+    "2021-12-01/rustc-nightly-x86_64-unknown-freebsd": "33a34b95e7b541b51e5ca6f0c0096757c9afef0a0f71e0f7320352882937d240",
+    "2021-12-01/rustc-nightly-x86_64-unknown-linux-gnu": "3b83f5195aa3a73fc9b17acdffd67ff6198f26c075d8b1e6c82a8bd717c3a031",
+    "2021-12-01/rustc-nightly-x86_64-unknown-linux-musl": "a82281cca27567897b58b85a3dad0888b6ce13d7987fbff3397501469bca579e",
+    "2021-12-01/rustfmt-nightly-aarch64-apple-darwin": "42a7f5965d0af7df73c7629e701708ddd59f9a2a3fb4b8656c78d5b0dde0c0ef",
+    "2021-12-01/rustfmt-nightly-aarch64-unknown-linux-gnu": "e8cfd49797ac43557ee2eae7543d95c1f9ef5b2d651ae026152b0ee38748bc9e",
+    "2021-12-01/rustfmt-nightly-aarch64-unknown-linux-musl": "c4b392988b1e6330a9275248118a348ff029d83d37ad948c568de280c8fb016c",
+    "2021-12-01/rustfmt-nightly-x86_64-apple-darwin": "6993786d7fc1223be21f0b11cfedc7cdbc0cc951f52445e982445e38dc4a5f0d",
+    "2021-12-01/rustfmt-nightly-x86_64-pc-windows-msvc": "d96a8c2622b511179a6c1b4a00e9aeb015d9ce33de40788358a6ef7e4b50215e",
+    "2021-12-01/rustfmt-nightly-x86_64-unknown-freebsd": "5ac0969e1c2e3009f739ea5cb12b87808045f43a0635ee8ddec0b2b04be00814",
+    "2021-12-01/rustfmt-nightly-x86_64-unknown-linux-gnu": "51f23dd0f8e14cab67f8bbd3a4aa142988ca0ab1155ddd2f37a22576dda6089b",
+    "2021-12-01/rustfmt-nightly-x86_64-unknown-linux-musl": "a58f271f8859c79b33f8b30a33cf91879a85f740c3f8ec99c75f21933b220b8c",
+    "2022-01-12/cargo-nightly-aarch64-apple-darwin": "28b2465970234b721799d0d7893ba3bd82db60dbfe9fce3ee280ba31e0cc05d3",
+    "2022-01-12/cargo-nightly-aarch64-unknown-linux-gnu": "a48f67a2e9b3158579abe99218029f7add37927dd96b7ee297b19d898264c82c",
+    "2022-01-12/cargo-nightly-aarch64-unknown-linux-musl": "20ecedf9cd58870c315bb215529b70d5d7efcc3091cbcd933097dbe3de643395",
+    "2022-01-12/cargo-nightly-x86_64-apple-darwin": "2960a0f4ea742d6c1af1293f21d6b88e5d1d87fa5cf12950a44caf6f3efc31cc",
+    "2022-01-12/cargo-nightly-x86_64-pc-windows-msvc": "58b3c44263e2cfdddc6c71604c0a20f730363ac29e7d2f86570a7910f753ce6a",
+    "2022-01-12/cargo-nightly-x86_64-unknown-freebsd": "fc83fb1358e6fe796879077ac8b79168694a6ddd2d8a0b90ef8bcdb6fdaa6aa0",
+    "2022-01-12/cargo-nightly-x86_64-unknown-linux-gnu": "2dc110d1caca2829ccaaf51cf4e553a1f5954364b7087c881efce52d18580817",
+    "2022-01-12/cargo-nightly-x86_64-unknown-linux-musl": "36b1c88f08eb35048937ee29a681405852198cbfb17fb29117f27ed185d2aaa1",
+    "2022-01-12/clippy-nightly-aarch64-apple-darwin": "22518551453026be28657094dc4d364369357bdc59c1ac8c785bc67d59f24acc",
+    "2022-01-12/clippy-nightly-aarch64-unknown-linux-gnu": "f89ca2df2eacdc7466feb2d502f81d3640bf1295d590011385366e331bc862a1",
+    "2022-01-12/clippy-nightly-aarch64-unknown-linux-musl": "e310f7b854e365c63e9a9449802b428cd9f21af336fa763c311cf8a541977f8a",
+    "2022-01-12/clippy-nightly-x86_64-apple-darwin": "2daeed49f7e7e85b2187177fd1d18e14400a0d38a5a717620d4af92deb17b4d2",
+    "2022-01-12/clippy-nightly-x86_64-pc-windows-msvc": "86e92e3f785272c354c548cf5220dd355798b786e0e8630cadf7fff3b4aac3e3",
+    "2022-01-12/clippy-nightly-x86_64-unknown-freebsd": "7bc87fd4a2ea153342a6144849a7786398713255c0ffc94f17a62a1a5ea36387",
+    "2022-01-12/clippy-nightly-x86_64-unknown-linux-gnu": "1d244ea2f27d4fc7447d4126b965620e6f6cca916db15a8f1f5df0f8bcb6e4f3",
+    "2022-01-12/clippy-nightly-x86_64-unknown-linux-musl": "b6e157718df8219bfe0c2cc67182d451b644aa7f8e0a3060f7676c4a53af0df9",
+    "2022-01-12/llvm-tools-nightly-aarch64-apple-darwin": "4dea9eb7156cce2856f06ce58b76039edf5452dc2dcfe1dbf2ca3e4a2a4513ef",
+    "2022-01-12/llvm-tools-nightly-aarch64-unknown-linux-gnu": "c8a61bf792a6fe1a2e10ccdb1684059626cbf077b6d82883549e0a824ec00fb4",
+    "2022-01-12/llvm-tools-nightly-aarch64-unknown-linux-musl": "e49c63a89360598a1ccaa4b4d452d6fe4f4974b70c1774125b7d0864984af4d2",
+    "2022-01-12/llvm-tools-nightly-x86_64-apple-darwin": "efee2f08143fbff836e6517ea7457468da07380dcdf8a3a19cb9eb7b3b36da7a",
+    "2022-01-12/llvm-tools-nightly-x86_64-pc-windows-msvc": "d9748a16a855057201581ee1a3f6105ddd00511bd3129ca1175139f686b0a1da",
+    "2022-01-12/llvm-tools-nightly-x86_64-unknown-freebsd": "73dd634e5b9361c52fa1ad9b3ee1126b5ee5f988165eee6e47f7c80bb1d02f79",
+    "2022-01-12/llvm-tools-nightly-x86_64-unknown-linux-gnu": "dbea5a53828f590af592386d880ada84c55a072d5c2cf2148a0aec16c86afa45",
+    "2022-01-12/llvm-tools-nightly-x86_64-unknown-linux-musl": "f4fbe5809cfc6271297de76f78bdbe0591fad5daa747a78fe43019d088048f61",
+    "2022-01-12/rust-nightly-aarch64-apple-darwin": "2976b38351b6133dd20f940210a9d7a36da7a63b4991f3dd7a977629a4e30a19",
+    "2022-01-12/rust-nightly-aarch64-unknown-linux-gnu": "67f91c94ed84cdeeb5c3d09eea11a01056befe6f8f199974c779e4a7c5580f52",
+    "2022-01-12/rust-nightly-aarch64-unknown-linux-musl": "d976d6d7d102c6dad026680cabc4ed44e21405f6afa28879ec24a78ccf9232da",
+    "2022-01-12/rust-nightly-x86_64-apple-darwin": "49bed5d3078cfdd9c95184909f80da529edf83c4b256ef2191dada8a22ba2d03",
+    "2022-01-12/rust-nightly-x86_64-pc-windows-msvc": "b0ee56ad0245dee798bd4f268fde3bcee58b081c0ed16e212773f273e04e7b40",
+    "2022-01-12/rust-nightly-x86_64-unknown-freebsd": "7ba2e7f96735a9021de7f6817be33c8f9c269ef8666cc8267682b3dd3044e5f1",
+    "2022-01-12/rust-nightly-x86_64-unknown-linux-gnu": "414208e1f535d760faa1b8074e20b32f1b045f42efda741677bb718a80980b60",
+    "2022-01-12/rust-nightly-x86_64-unknown-linux-musl": "d9b2a94d67e6484a17b6f128cdc2ecc081068a7730b93cc480b9886dfbdaf523",
+    "2022-01-12/rust-std-nightly-aarch64-apple-darwin": "eead24d761bfa6ef0c926d59ed2cfeb51dc68fa4c13d59672289a6cc5795d990",
+    "2022-01-12/rust-std-nightly-aarch64-unknown-linux-gnu": "80ef127c8e0f8b2a9d4d6dd6c59e3b27c07ba7234e3fa2d8155227bdcaf18349",
+    "2022-01-12/rust-std-nightly-aarch64-unknown-linux-musl": "9716a07e0255737c1a5882cc8d053906bf82fc2cad0e86184d7dc12780811136",
+    "2022-01-12/rust-std-nightly-wasm32-unknown-unknown": "52f08158233d16c2b6b26b009f438ffbf2d60c4acbee4c8dba0718d363112637",
+    "2022-01-12/rust-std-nightly-wasm32-wasi": "318294f44e7dfe947445d03fe048465fce57a8acd4d39c45b04d64f8c5681950",
+    "2022-01-12/rust-std-nightly-x86_64-apple-darwin": "32a2f359a66e9257afb3166c3f3d03b46cccf15d081ff1962b6b6dc7589d16fa",
+    "2022-01-12/rust-std-nightly-x86_64-pc-windows-msvc": "fed0b46a7278a327827169f0dfc829ec3d11ca64c86b59b73e9a5164c6d4f865",
+    "2022-01-12/rust-std-nightly-x86_64-unknown-freebsd": "ad8c17b3a32d325a546bf22a6a5744e6dd448cdbb103c8687c9a7de622317474",
+    "2022-01-12/rust-std-nightly-x86_64-unknown-linux-gnu": "a0574b2ae49a860d69f66d8060ef42e764be73ccffe3ecbc1dbd5bbdbe9c06d4",
+    "2022-01-12/rust-std-nightly-x86_64-unknown-linux-musl": "ca442e0a9ca4c94ced9de08ece921be187ecc1b540518be76a7029fd7142eeb6",
+    "2022-01-12/rustc-nightly-aarch64-apple-darwin": "dc5fa145966daf5ec010e0b83f3b115866683ac418667e39663ea13a8e490d7c",
+    "2022-01-12/rustc-nightly-aarch64-unknown-linux-gnu": "d6183b88df1f868862bd3cf138f25179ba2fdab7f16e2d14577ddd56731ea18f",
+    "2022-01-12/rustc-nightly-aarch64-unknown-linux-musl": "1915a5b04ed3cde9f2566ca7f5205e37b706fc5cacc9ac64b7e6d818d882f39e",
+    "2022-01-12/rustc-nightly-x86_64-apple-darwin": "c51b1b7830d302fd352d4e105282da0c2aa01d98a7d8c0b0018db24539f2fb0c",
+    "2022-01-12/rustc-nightly-x86_64-pc-windows-msvc": "69edaeee958c53a2ae99813994f60b27198538e288217bc30862668975e01144",
+    "2022-01-12/rustc-nightly-x86_64-unknown-freebsd": "cca63c6998d9762616c74518dd870fe67432fe0442003211ba58f0f1e3953e46",
+    "2022-01-12/rustc-nightly-x86_64-unknown-linux-gnu": "4cc6346b16182c580c1fdee2ed35061d57140422d6e13f04b0f21db4ad9a9105",
+    "2022-01-12/rustc-nightly-x86_64-unknown-linux-musl": "1716aae4bf44c58ffa91121661e78fe112cfa5655dd2e98675e2dced7a4818cc",
+    "2022-01-12/rustfmt-nightly-aarch64-apple-darwin": "458b707f541a604cf4463a99e7c9f6dabb5222c815b7278735a8147ed6a6d8cd",
+    "2022-01-12/rustfmt-nightly-aarch64-unknown-linux-gnu": "edb9f32b1d8228362a17ffc83d47479bd247000d50f9cb4c0fbf4570557139c2",
+    "2022-01-12/rustfmt-nightly-aarch64-unknown-linux-musl": "34299938e1f5d06f048b992f5bc57f17b5d07d7417dceafdd67d64f893c609ab",
+    "2022-01-12/rustfmt-nightly-x86_64-apple-darwin": "eb6716d438d6923cb8b6cc1220fbfc30cca77548c19d1ec4656c4041dc680b73",
+    "2022-01-12/rustfmt-nightly-x86_64-pc-windows-msvc": "a29f9343d63ba3982eb3c783777430a864eee8bee0191c3899f7abcddfb0de0a",
+    "2022-01-12/rustfmt-nightly-x86_64-unknown-freebsd": "b53e01c1d038ce6ee92bbedd0d4c5ae9942521a36d937ec9cf43caaa73278eb8",
+    "2022-01-12/rustfmt-nightly-x86_64-unknown-linux-gnu": "edf5018504be0d79d77615a0c7e029a378446e2fd1a5360d86d97196519b510b",
+    "2022-01-12/rustfmt-nightly-x86_64-unknown-linux-musl": "237bef02a341db60e3af388feb7d7351d13da9728cc8fa10bda5631f812b2a58",
+    "2022-01-19/cargo-nightly-aarch64-apple-darwin": "e0bbae6fe4ea276773d426fb171fdca151c8877406476ef9200fbdc296d2f2ab",
+    "2022-01-19/cargo-nightly-aarch64-unknown-linux-gnu": "1fc5a3fe7ae76b2a332c95357f1b01c75341d022d66b918e8b2d9500fdbac74d",
+    "2022-01-19/cargo-nightly-aarch64-unknown-linux-musl": "06f0c843e0694a9fbd6f52d4257cea7a9ce7b0cfc519134cac03f85ac103839b",
+    "2022-01-19/cargo-nightly-x86_64-apple-darwin": "55e64aad2d07a7d1aecf3fe417039f20ef5b794e7597be0d5d0ab3098b439b39",
+    "2022-01-19/cargo-nightly-x86_64-pc-windows-msvc": "c8f22a3ce1edb3632148b0117198947f80f1173b5e034468d039db9734d727ca",
+    "2022-01-19/cargo-nightly-x86_64-unknown-freebsd": "f088c70c08c55564c11a10698881a7317d44e934fc4054e65f45c4e721c8c663",
+    "2022-01-19/cargo-nightly-x86_64-unknown-linux-gnu": "9dba5c80dc04089d3fffbd2bb066721a2ea3a4ef5772620d64083dec6fd7ba9e",
+    "2022-01-19/cargo-nightly-x86_64-unknown-linux-musl": "0019a2625020210edf0df9f77a805ee404d59c00bea1013020dfd9d1f63a428b",
+    "2022-01-19/clippy-nightly-aarch64-apple-darwin": "3e552735b0f7edad6333514da898a374f089045918916fc86ebd6d1b2f146813",
+    "2022-01-19/clippy-nightly-aarch64-unknown-linux-gnu": "261eaaf4cbe038fe99f437f41a6479f1c85178b68b86ba322363c3a988a41df5",
+    "2022-01-19/clippy-nightly-aarch64-unknown-linux-musl": "98ab9cbc764859416b199498cdaa29f3e0530b9fee37a00194575102d1d18614",
+    "2022-01-19/clippy-nightly-x86_64-apple-darwin": "57bbd4e12dfe619bb38ca51e0457c7a0458ead39a5f8b8009e82c3ff782ef534",
+    "2022-01-19/clippy-nightly-x86_64-pc-windows-msvc": "f9415462ee2982c546bf4cdebf513292dfe380366604b0da3533ffcb7b062f58",
+    "2022-01-19/clippy-nightly-x86_64-unknown-freebsd": "6732077fb8ae4cbf038c7d56ad2d73e08dc7fe214618c1b8048d5886a0e38782",
+    "2022-01-19/clippy-nightly-x86_64-unknown-linux-gnu": "8a84d8d4120ab3a9a1843fb4b343531ce2f66e472f2bd9b4adb6e825c336130b",
+    "2022-01-19/clippy-nightly-x86_64-unknown-linux-musl": "1472e5cd4b2950bd22a2e6feaafd01f7a2a8b726f12d6152b262474fa2cb57c3",
+    "2022-01-19/llvm-tools-nightly-aarch64-apple-darwin": "669057387a1515c3c4529786f60b9a25ac5c4eda911422fb023b73fa8a380a36",
+    "2022-01-19/llvm-tools-nightly-aarch64-unknown-linux-gnu": "7afb1e98626316cc1de6b62edb319b5f006da5c24601bb657c5cf567555b5730",
+    "2022-01-19/llvm-tools-nightly-aarch64-unknown-linux-musl": "e9bf498717ca2e8c7620957a5f7846b53dc09a7c720e8ec31e67c8da25fa59b0",
+    "2022-01-19/llvm-tools-nightly-x86_64-apple-darwin": "de72f572574a1238dbec6ee6b5c48e31b6770826cbcb6ecc61c568587c82ab66",
+    "2022-01-19/llvm-tools-nightly-x86_64-pc-windows-msvc": "97f9c947d726b72ab318705b539e11012a73a08dcb79e00c73d680d9a5166882",
+    "2022-01-19/llvm-tools-nightly-x86_64-unknown-freebsd": "2e42c56a825fa9bd640fbb3bafecb02cfe68877e09d1c0ddfdff794e4571a2a7",
+    "2022-01-19/llvm-tools-nightly-x86_64-unknown-linux-gnu": "bfd89e74330fc0f9d61b75852c96d644fe5ffd90636e8668f10480e27cb8593c",
+    "2022-01-19/llvm-tools-nightly-x86_64-unknown-linux-musl": "5dbbbbee7bc11793c320608b5c88398206b8803593e8906ac03b5651bb7b7a6c",
+    "2022-01-19/rust-nightly-aarch64-apple-darwin": "9a0a4323eba39da2c0ae9dd99eae994c90019b11e1020378781fb41521799b92",
+    "2022-01-19/rust-nightly-aarch64-unknown-linux-gnu": "c71d05f5ec4d1d118bab9b3155086328093b5b620b39de3e541294dbb64d4ace",
+    "2022-01-19/rust-nightly-aarch64-unknown-linux-musl": "9aca1ed8d3283403931991b4c46d5f57a0839bac3ac5283692ef67938d291470",
+    "2022-01-19/rust-nightly-x86_64-apple-darwin": "1102c26afe2de2c73079c30b038ac203e1b2d647383338f91782196b05a11116",
+    "2022-01-19/rust-nightly-x86_64-pc-windows-msvc": "bb63d762cac5570f98c4109c7d4cd86d5912b46d0779f44a27fd515e1b723961",
+    "2022-01-19/rust-nightly-x86_64-unknown-freebsd": "726dedec423c51031d5d481aa90f04cc68ed52f45cc33320a6932e02adaa8256",
+    "2022-01-19/rust-nightly-x86_64-unknown-linux-gnu": "db2ec42968696da58de511cb088ea0f879cc64551a8944e5673f73df0e252b7c",
+    "2022-01-19/rust-nightly-x86_64-unknown-linux-musl": "49e42ceb3358ee50863db105c680bbe35aae62b0c27d21db4124b29e82203137",
+    "2022-01-19/rust-std-nightly-aarch64-apple-darwin": "2640f188bda156f0c530c558e02b06dd1b362c7c0115ef8d9e585d451fd92c55",
+    "2022-01-19/rust-std-nightly-aarch64-unknown-linux-gnu": "500e3edb2fe3776ddbb85cbbfd3cea154f969d9b7b76df208dd39953a96d04db",
+    "2022-01-19/rust-std-nightly-aarch64-unknown-linux-musl": "1f93e986d03402e01d70bb443540049d641aa3bdc7376691ae4347addaf17642",
+    "2022-01-19/rust-std-nightly-wasm32-unknown-unknown": "419ecbb51cecc803299d3868b34e78cf08c589b9ce89edc58e9eb99a12140682",
+    "2022-01-19/rust-std-nightly-wasm32-wasi": "4a267c1c645e8269bdaf29b6edebe88bc2149217e9eaf0f9f87877c67540e9db",
+    "2022-01-19/rust-std-nightly-x86_64-apple-darwin": "b875843a7a5ec1b7f9a45672e44495b17972c0268a20d706610ee9c6ee12e408",
+    "2022-01-19/rust-std-nightly-x86_64-pc-windows-msvc": "316b1efb302c7f58f59aaa822fe07e809beafc4ab157d0dc53b92786292f7a4a",
+    "2022-01-19/rust-std-nightly-x86_64-unknown-freebsd": "632eba5d1ed2eed44fc61a1a69014e756426cad86accd2c372d44e07c764d1b8",
+    "2022-01-19/rust-std-nightly-x86_64-unknown-linux-gnu": "f1a26b04468f05a0239ff7d9bf4991ff6150650dfaf4d0a68b51d2146a1fe7e5",
+    "2022-01-19/rust-std-nightly-x86_64-unknown-linux-musl": "33f9b31abca43c27afe34800fcfa87fb66a059b4ed9a2ff6ba9767e0609ec2af",
+    "2022-01-19/rustc-nightly-aarch64-apple-darwin": "d1036828856da3195883e4c56b6596a08d3ed75ea5875cc26642e5b3b8caccd1",
+    "2022-01-19/rustc-nightly-aarch64-unknown-linux-gnu": "3f7edd43d97a6c63ad43db071989ed4114dff29c77b5b7ed7e1ea65339e170d0",
+    "2022-01-19/rustc-nightly-aarch64-unknown-linux-musl": "9d5d70aa8942786a61e4f7026abad946f5d965a99f44fcde54d5fde286461f52",
+    "2022-01-19/rustc-nightly-x86_64-apple-darwin": "0bb3422db5ebdbb36bd487ab6ec0b0bc89c960bf5b8bb1fadb9a7f3b827d0672",
+    "2022-01-19/rustc-nightly-x86_64-pc-windows-msvc": "2f15ce047f6c8ca20d4585ade8f66b7f296de7083da5636e5a09f04b02228435",
+    "2022-01-19/rustc-nightly-x86_64-unknown-freebsd": "1c8e731ee63cde0f5d6375590b234c5facf4070584494c24ae6d3c012e81b74e",
+    "2022-01-19/rustc-nightly-x86_64-unknown-linux-gnu": "8f96fbd32d86e0943a5d15c967c1e4d9832bd8682eeae1f333e9bcb77433acc8",
+    "2022-01-19/rustc-nightly-x86_64-unknown-linux-musl": "9ca8f7801aeea115aef2648313ed05f5755cb4fab2ca93e391dcc0b09f79528c",
+    "2022-01-19/rustfmt-nightly-aarch64-apple-darwin": "e1cd639473e54569e0282d68bd2270fa1f2e9713c8cdc95e1432097fabe3ab3d",
+    "2022-01-19/rustfmt-nightly-aarch64-unknown-linux-gnu": "f6e70a862dcdf24b035061602b1081163083ed022bf15366337fdf5af5b999b8",
+    "2022-01-19/rustfmt-nightly-aarch64-unknown-linux-musl": "eb028b9c1fda5730ad387312eb6fca48da94cb654edaa0a6a445092b1bd28af2",
+    "2022-01-19/rustfmt-nightly-x86_64-apple-darwin": "e205536ecdb2e15243a2436a41fc398b6a558be98d1ae8b281e9dd3748f3931f",
+    "2022-01-19/rustfmt-nightly-x86_64-pc-windows-msvc": "571d43d9091f87debf76102801a9d65842314532af34f08fec9de1b8346e532e",
+    "2022-01-19/rustfmt-nightly-x86_64-unknown-freebsd": "194f0c425d9188ceb69233069b162b25bb829c8fc155979433457d63b32df61d",
+    "2022-01-19/rustfmt-nightly-x86_64-unknown-linux-gnu": "3cab5f9cc9fb0681ce5c284b5ac98e92cbf73c2c9eb993d7d7d9faaf3363f01c",
+    "2022-01-19/rustfmt-nightly-x86_64-unknown-linux-musl": "41233d3f0fad709cc751def5342849564446cbc3a00045b39cb6a8c26d7dc436",
+    "2022-02-23/cargo-nightly-aarch64-apple-darwin": "16cc0baabdb131b3739d5db9d98a26db494a470afb15c29fb3f30a8a9701ffa7",
+    "2022-02-23/cargo-nightly-aarch64-unknown-linux-gnu": "c7b2643282f256f01224d93af31e722ff0ff64780fe391fdf1343aabe03b3a30",
+    "2022-02-23/cargo-nightly-aarch64-unknown-linux-musl": "3a4cda34180864cdf9505316e985460018756717878f8529c9141a982683c7aa",
+    "2022-02-23/cargo-nightly-x86_64-apple-darwin": "4952a58521c389ebbbf12d5c5f855d7ff63b6cbaa8b39f5d0410638ce18f91b5",
+    "2022-02-23/cargo-nightly-x86_64-pc-windows-msvc": "2909e511824b752f9137c1312076a3b570dcf9df19823c41b188db9859f44830",
+    "2022-02-23/cargo-nightly-x86_64-unknown-freebsd": "c5d47b6b075ff2bb881f1fe07f89e0927beb23cdb169c293e976853833421f96",
+    "2022-02-23/cargo-nightly-x86_64-unknown-linux-gnu": "ef101ce313d0d045ed121e312b12bb41c20bdc07963543ab77c5a5ab9802eb02",
+    "2022-02-23/cargo-nightly-x86_64-unknown-linux-musl": "dbb5a85a3d753473e5595b12c08b217aa8c13b01c64cffef5c702025d2557c38",
+    "2022-02-23/clippy-nightly-aarch64-apple-darwin": "59778a7fbd8a5fe3bade8b95d7ff7ec1419dfa95e2271afa6b32baa1d5c3710f",
+    "2022-02-23/clippy-nightly-aarch64-unknown-linux-gnu": "62d3027e541c8fc87acc076865469af0020b1ebff97ebf45dabf0fa3537ee7be",
+    "2022-02-23/clippy-nightly-aarch64-unknown-linux-musl": "dacaa625832e840e464ce5c0dc5bbefe5e15b1faa9fdf1fd29f4a5a9c6d955c6",
+    "2022-02-23/clippy-nightly-x86_64-apple-darwin": "7f98beae8363a2be260f2adaca025408abb092894138ae5a00cb43f8cffe5fab",
+    "2022-02-23/clippy-nightly-x86_64-pc-windows-msvc": "695c78fd375ca2e67d2b2dc679c242de32e7ec6366ac39c1060de9f4bb34c97e",
+    "2022-02-23/clippy-nightly-x86_64-unknown-freebsd": "674891a88d78046afb4da489ab47bf2994a7aab4c65eea42639611cc992114d0",
+    "2022-02-23/clippy-nightly-x86_64-unknown-linux-gnu": "b510582d9ea92fb059c89deff9a74a9725c8e935daedefef20443ce44e8d40d7",
+    "2022-02-23/clippy-nightly-x86_64-unknown-linux-musl": "f582add076fb61857c380258c0d854b7601381ba3dae7ae5b423978511159ed7",
+    "2022-02-23/llvm-tools-nightly-aarch64-apple-darwin": "b35cc47bd525e6664592f403905866c48bb9cb7b1b409bcf63c2b35d32993a79",
+    "2022-02-23/llvm-tools-nightly-aarch64-unknown-linux-gnu": "4c02f526bd993a9118ac0ac610b85e5cdfd42bc43d7ecf77d8c3067893c8a54d",
+    "2022-02-23/llvm-tools-nightly-aarch64-unknown-linux-musl": "b857b033803a4d6020c3425af9d4ea2b0462cc2db67f549e7dd426f81265d48c",
+    "2022-02-23/llvm-tools-nightly-x86_64-apple-darwin": "5e26961b8f803ca6d5be40622a8580164986bf54d8391b1a4524fcffbd1eeb10",
+    "2022-02-23/llvm-tools-nightly-x86_64-pc-windows-msvc": "dd5f7e54725d973423b3cb2ff3a0492da76491911591f6b34231af1dce332a7a",
+    "2022-02-23/llvm-tools-nightly-x86_64-unknown-freebsd": "dfb6f74016e677c28cf6eeb9e8430f5022e0c874619e2f5235728e82416e443c",
+    "2022-02-23/llvm-tools-nightly-x86_64-unknown-linux-gnu": "2746d97f126edf2045f012591c1262d725cf042c56c32caf7ecdcc0eb1ae001e",
+    "2022-02-23/llvm-tools-nightly-x86_64-unknown-linux-musl": "d307f34ba5fdfa7f4a4645e76a9bf8447c3baaf404017b0c698e516c3be5b56c",
+    "2022-02-23/rust-nightly-aarch64-apple-darwin": "e00ccb8acffe7450d78c5b2fc13cbc01a5210ad8edcaf27bf4a7961806942ae7",
+    "2022-02-23/rust-nightly-aarch64-unknown-linux-gnu": "f9b5613cb5ba524dfe8ba7325c2b8f8f112173d3e1a9bc5a75de49a604f4c379",
+    "2022-02-23/rust-nightly-aarch64-unknown-linux-musl": "a87bc336ca122847a998bcbfbcd9b1b7232c7cab7219a63948ec73bb2b9563bc",
+    "2022-02-23/rust-nightly-x86_64-apple-darwin": "a585cbad9e35c3a2da5d0037078501a01edaf66d9e52ac2e4394b733dd5ac81b",
+    "2022-02-23/rust-nightly-x86_64-pc-windows-msvc": "2df97bea4add36de47074a5d70d84f3f2cb29f038b6ca82af4e7986ef5bc9acf",
+    "2022-02-23/rust-nightly-x86_64-unknown-freebsd": "fa6b2300d71c7fab41a2c9a6b8a6b210eed8d3fe8263e8e17f2034072dd15c94",
+    "2022-02-23/rust-nightly-x86_64-unknown-linux-gnu": "d0fcb7b0e2b9b09ecca0954af53732c647859c3140b79fb2c1bd61af9846c3d3",
+    "2022-02-23/rust-nightly-x86_64-unknown-linux-musl": "00ed0db2ed84d6ab0347b663963b7ceba40483a9f40316e6f57872dbfc5ef395",
+    "2022-02-23/rust-std-nightly-aarch64-apple-darwin": "66623fbb88fb63ce610dfe1d5b3242620f1bd473386950b33c3383cc064f8743",
+    "2022-02-23/rust-std-nightly-aarch64-unknown-linux-gnu": "c6f82581224c8d968f0e747b07b6651f96ad8736aabe912ca9fadab7a82e7e5d",
+    "2022-02-23/rust-std-nightly-aarch64-unknown-linux-musl": "fda164074a8a6329835d99423a51a921948aaa67a2c6a3982940f73fe62b1a35",
+    "2022-02-23/rust-std-nightly-wasm32-unknown-unknown": "607a92b4e349601d6d7b4575b303324ec8af153fbfa19d6171eccd72388d6f63",
+    "2022-02-23/rust-std-nightly-wasm32-wasi": "4702cab8d82ae958c984686df053897ee53ae98650046016053261c922e848c4",
+    "2022-02-23/rust-std-nightly-x86_64-apple-darwin": "e6f2d3e182060387bba51540a6a8207f22cdf2f28f510143164bc755adf3d717",
+    "2022-02-23/rust-std-nightly-x86_64-pc-windows-msvc": "940c6687afd93a499e634fa31613d635f8f74ca6c16fb677a418f7288c8b80ad",
+    "2022-02-23/rust-std-nightly-x86_64-unknown-freebsd": "b685a785f022c76231c716d1ea305d03e46c7c785e5ce38be895d357e20b044f",
+    "2022-02-23/rust-std-nightly-x86_64-unknown-linux-gnu": "515506678fc829b3d418e124fa44ac29a5c485377d3fc753493e16aeed856f2d",
+    "2022-02-23/rust-std-nightly-x86_64-unknown-linux-musl": "5a9b8bf339631e33b45704a4f071991ba0694c7b00d94d35793a86ebdb5ad354",
+    "2022-02-23/rustc-nightly-aarch64-apple-darwin": "e967e5e396f7a931f53f7a9737591c4bbfdbeec869495b3cfbce8ccb18c54fa0",
+    "2022-02-23/rustc-nightly-aarch64-unknown-linux-gnu": "7a222bd902f3faa17b486027b357f461659a54f7ba81dc1b784a450d6b06f81a",
+    "2022-02-23/rustc-nightly-aarch64-unknown-linux-musl": "c898784e3e4e2fc0492c53148857ec7eff61bdda44b608a3d06e88b7e30372c9",
+    "2022-02-23/rustc-nightly-x86_64-apple-darwin": "4976dd96f04ef65f948deb988fa9ad7adfbfbd4873c0c78657830f18cd565d4b",
+    "2022-02-23/rustc-nightly-x86_64-pc-windows-msvc": "aa55308792edfdb41d1e7121e0343c05847b7e860ece9ff4c9534d64084b09bc",
+    "2022-02-23/rustc-nightly-x86_64-unknown-freebsd": "32b6dce6fabc18617d7b2295e45ff30221a68979b8302bde97c98596047f2a0e",
+    "2022-02-23/rustc-nightly-x86_64-unknown-linux-gnu": "d30ae66c6ad9f0292effe047d7977ecf1f2f6c5be783cfa110c54fdb5bd8396a",
+    "2022-02-23/rustc-nightly-x86_64-unknown-linux-musl": "355e30a7f4416a2db738d950b40d0eb57fc734f59871e1291349509e74f1be09",
+    "2022-02-23/rustfmt-nightly-aarch64-apple-darwin": "8f4bc35d8e2b03db96a5d9faedb5e25155082d96621c26b90734219468904c62",
+    "2022-02-23/rustfmt-nightly-aarch64-unknown-linux-gnu": "88691ff2cefa6880cb4bbe2d717b5419cd0440ee0d000ff8a70f9d86d714b866",
+    "2022-02-23/rustfmt-nightly-aarch64-unknown-linux-musl": "394ee236b37b687963a0c42e40b3c6863460c302429ad00ca37c7931ea896233",
+    "2022-02-23/rustfmt-nightly-x86_64-apple-darwin": "6e7ba1d83b61ce690c857bc197f3c0a1cf0cb2afd3c4c7f16fdb4079f460ce6f",
+    "2022-02-23/rustfmt-nightly-x86_64-pc-windows-msvc": "e1a81be6159fb9e28cb1f35ac4508a09a0be86edf6ab39db08988a5bbefa9e76",
+    "2022-02-23/rustfmt-nightly-x86_64-unknown-freebsd": "63a0018ed3b7bf94dca3db30be7a1d6940a7559cdd0ca408c366551e2f5e6863",
+    "2022-02-23/rustfmt-nightly-x86_64-unknown-linux-gnu": "7ab236ced294c39de4bb563e9ebaed04c906a4ccfd1932138d37d6d03f75cae7",
+    "2022-02-23/rustfmt-nightly-x86_64-unknown-linux-musl": "647da2183d93846ac5225b99117846a07a90975bdf1b5075e86601dcf97d1ecf",
+    "cargo-1.48.0-aarch64-unknown-linux-gnu": "71347016f0da96d4250225f7b52701274df958870b1a65482badb87d661035f9",
+    "cargo-1.48.0-aarch64-unknown-linux-musl": "873883a9f6eb2e0cae7dafdc6c4262157298b7bc6ac5c3ed899ed1f55cad7e82",
+    "cargo-1.48.0-x86_64-apple-darwin": "ce00d796cf5a9ac8d88d9df94c408e5d7ccd3541932a829eae833cc8e57efb15",
+    "cargo-1.48.0-x86_64-pc-windows-msvc": "c1287b03522828b527ba95a5bc9de0246efa4365a43d22a212f50a5ca2ea1487",
+    "cargo-1.48.0-x86_64-unknown-freebsd": "55fcdad2ac3a3f8066c323f75fb2b222822023f8b9961317d710f2f43771aa62",
+    "cargo-1.48.0-x86_64-unknown-linux-gnu": "52bf632e337a5e7464cb961766638e30dfa28edb3036428296678d1aaf7d8ede",
+    "cargo-1.48.0-x86_64-unknown-linux-musl": "0dd47d6342b17bc6c0fbf9ec007be0c90274e40e76d8e6a88cac73ecafc1583a",
+    "cargo-1.49.0-aarch64-apple-darwin": "2bd6eb276193b70b871c594ed74641235c8c4dcd77e9b8f193801c281b55478d",
+    "cargo-1.49.0-aarch64-unknown-linux-gnu": "fce2bd0eabf9a9958b02f5ede3c227c992ee7048ab34293cce57bc3d48e63fc0",
+    "cargo-1.49.0-aarch64-unknown-linux-musl": "18b4fa2d7a737754ae2d5ce3a2f8c8881fc4d9b5aae20109d7d3d622cf3ac145",
+    "cargo-1.49.0-x86_64-apple-darwin": "ab1bcd7840c715832dbe4a2c5cd64882908cc0d0e6686dd6aec43d2e4332a003",
+    "cargo-1.49.0-x86_64-pc-windows-msvc": "84b44835a3f275fef70cd86a527d086c537e59fb3209fe8bbef1eeb1da6edbb6",
+    "cargo-1.49.0-x86_64-unknown-freebsd": "320aac1e31eed2db657380bce2d8ff8b65fc8de59f4aadabf8219bcb6b4ce1a1",
+    "cargo-1.49.0-x86_64-unknown-linux-gnu": "900597323df24703a38f58e40ede5c3f70e105ddc296e2b90efe6fe2895278fe",
+    "cargo-1.49.0-x86_64-unknown-linux-musl": "c2a3d3b27ac105acf7bfc25d6e401b9ac369597f57220332377b98b2f8cb550b",
+    "cargo-1.50.0-aarch64-apple-darwin": "19d526ef3518fb0322f809deddbd4208a27d08efa41d2188348f1be8d3bcfe5e",
+    "cargo-1.50.0-aarch64-unknown-linux-gnu": "9b6fbfec7f6d14013387433f3a907b1f474027d7f32f626dc1c5ca83faefe573",
+    "cargo-1.50.0-aarch64-unknown-linux-musl": "7ec67e55fe541cfe32221e9b69349d2de83a24f7967f58eb4dc06e59f321babf",
+    "cargo-1.50.0-x86_64-apple-darwin": "45640bb1cef40f25ecb4bd2a3bb34fdf884c418e625d4f9c9595d2aca84fad78",
+    "cargo-1.50.0-x86_64-pc-windows-msvc": "dbd97ac5645668149d4a32b0b5f6274934d95f8b6d6e6926b7de13ee869aeedb",
+    "cargo-1.50.0-x86_64-unknown-freebsd": "97cbdc9b94123e940f7ed7304aba418a1a10ee1cca5acfe302e841ea39efa190",
+    "cargo-1.50.0-x86_64-unknown-linux-gnu": "3456cfd9be761907a4d3aae475bd79d93662b7aee4541f28df3d1f7c7d71a034",
+    "cargo-1.50.0-x86_64-unknown-linux-musl": "f1f99e1cfacaa69a12c4ee7ffd767bdcf80eb4d4b0e71af545e8e16b2b22d799",
+    "cargo-1.51.0-aarch64-apple-darwin": "3eb0eb6192635c4b844deb97004a7e38a631bb4507b1284c055df8533c00e77a",
+    "cargo-1.51.0-aarch64-unknown-linux-gnu": "eeeee860ec47ebe1c45f497ff99cfee9c869a592db573cd547a67681db695616",
+    "cargo-1.51.0-aarch64-unknown-linux-musl": "297a66f911298c55e7a494286769c045184e7b65fb3dc0a56d5a00d8655c6341",
+    "cargo-1.51.0-x86_64-apple-darwin": "37eb709e5ed8fe02d2c8d89bc0be3dc1d642cff223c25df311ff5a82eab53d4b",
+    "cargo-1.51.0-x86_64-pc-windows-msvc": "ee232ab24aa57f3c57218a5886af673725ecff38ad58e8d75257d4fd0c86b148",
+    "cargo-1.51.0-x86_64-unknown-freebsd": "fb2b8a5fd787944392adec0593f6921131069a5a95c1f53be75f98451d918300",
+    "cargo-1.51.0-x86_64-unknown-linux-gnu": "fe8abe2c2b467ac5f5021ff8020eda70de9e9f8f45b4a2e834afbd3b78323a31",
+    "cargo-1.51.0-x86_64-unknown-linux-musl": "3e3f1ca2aba2d7195bc447f4e446bbf6c8803f42ebaaf7a32e7f92268cf2f6ff",
+    "cargo-1.52.0-aarch64-apple-darwin": "86b3d0515e80515fd93612502049e630aeba3478e45c1d6ca765002b4c2e7fd8",
+    "cargo-1.52.0-aarch64-unknown-linux-gnu": "4a7f07bd9f30ed0409a21fad831afec0b9d0d10b5bca10cf826fdefe04a4f4f9",
+    "cargo-1.52.0-aarch64-unknown-linux-musl": "472cd83b79e173932ff436e77802c217599f73f672e88345bb61105dddf2a2eb",
+    "cargo-1.52.0-x86_64-apple-darwin": "02a4be4aae1c99ca1e325f9dbe4d65eba488fd11338d8620f8df46d010ffbf3a",
+    "cargo-1.52.0-x86_64-pc-windows-msvc": "866fc858fc422fa52afdabfb5feaf6e6aed41c575d6edfd4f343425faaf01023",
+    "cargo-1.52.0-x86_64-unknown-freebsd": "c732090f26a36211de084fba0ffcc8d1b49591d935d3b4ebd515a9570043aeb2",
+    "cargo-1.52.0-x86_64-unknown-linux-gnu": "85151d458672529692470eb85df30a46a4327e53a7e838ec65587f2c1680d559",
+    "cargo-1.52.0-x86_64-unknown-linux-musl": "ecb7b4968ca1b19c09ac3de9ea60420e8435c32e25f7412c19a0ac3f9dcb3363",
+    "cargo-1.52.1-aarch64-apple-darwin": "6787f8746cedd005b7abeabf6e2250ebc5fa767486c5bf23c597298e6965d576",
+    "cargo-1.52.1-aarch64-unknown-linux-gnu": "d2e15beebe22b6f6380d233f48599fc1b9228b064f0915eea02b2376f0bde1e1",
+    "cargo-1.52.1-aarch64-unknown-linux-musl": "dc8f6cf0c02f68b05b470087cd611cc4107060daae64f9d09677e97389c51281",
+    "cargo-1.52.1-x86_64-apple-darwin": "40d8fe950202763f633b6dd927f8e546e0a44b4b959945310c9eeb77f69e72d1",
+    "cargo-1.52.1-x86_64-pc-windows-msvc": "bb25d1ca297ac99a1dde7ce537880c1f5a37e392257b5aba589938b4f1bbf659",
+    "cargo-1.52.1-x86_64-unknown-freebsd": "67f858cf9e46fb7efe825adb854302e187ad194d05ded1e7b8ce165607869947",
+    "cargo-1.52.1-x86_64-unknown-linux-gnu": "f3225c27ce16296400389285358b61e138811c2e0eb1388593817688145ab64d",
+    "cargo-1.52.1-x86_64-unknown-linux-musl": "300c30d1ad47c84a8d806ef492db2478bc7c17793b92513533166bd9d9b51857",
+    "cargo-1.53.0-aarch64-apple-darwin": "5f0aea0cd507ff6e3b1e1ae54a8726172d055a8b6d8b1ba550ce9ebc96a8a891",
+    "cargo-1.53.0-aarch64-unknown-linux-gnu": "7c35c086e294af3ae82df5609c6833a36bd8e6634e8ecca18f863829cfe80ca7",
+    "cargo-1.53.0-aarch64-unknown-linux-musl": "9c0e9137aaf5c13f9d65487ec3216fe39280f387be4133da088355e263ce42da",
+    "cargo-1.53.0-x86_64-apple-darwin": "b42f4a7d054e219d8744af48cfab798473981455a050a320c46b164382726e50",
+    "cargo-1.53.0-x86_64-pc-windows-msvc": "7ab1bfdee65f19cb60671690566b89e3a0f210f04dd53078786f6c708b523223",
+    "cargo-1.53.0-x86_64-unknown-freebsd": "3e2c5681793c86f21133ac7b26aa5af4525b8471ec5df840d41d0e563fb675c8",
+    "cargo-1.53.0-x86_64-unknown-linux-gnu": "e79d9d0b03cb331428ef3cfc4cbe60ded9f90708a7dd1714d974dab9a03ee7b3",
+    "cargo-1.53.0-x86_64-unknown-linux-musl": "d8f632c0b2f8abafb1149446c695a8a7024134fa62faa37ac8922a41dd66c95a",
+    "cargo-1.54.0-aarch64-apple-darwin": "7bac3901d8eb6a4191ffeebe75b29c78bcb270158ec901addb31f588d965d35d",
+    "cargo-1.54.0-aarch64-unknown-linux-gnu": "d54d0bde0014e73a9c6943665bd236e5596c86d58869bc758aa6c24a9ad53061",
+    "cargo-1.54.0-aarch64-unknown-linux-musl": "2dd6ecd46b769efbb397794e5bad4249779be3e91738efd26a7673fa728a5ac0",
+    "cargo-1.54.0-x86_64-apple-darwin": "68564b771c94ed95705ef28ea30bfd917c4b225b476551c998a0b267152cd798",
+    "cargo-1.54.0-x86_64-pc-windows-msvc": "ad8808314e36af5de8e3e8e519c4e73d30b56a8020418aec2fd1f0f3d2d7a8f6",
+    "cargo-1.54.0-x86_64-unknown-freebsd": "3a2612b2073f5d3b45a4c88f359a8f5e2b86b85f7ef68bda518f532339f01227",
+    "cargo-1.54.0-x86_64-unknown-linux-gnu": "8c4f404e6fd3e26a535230d1d47d162d0e4a51a0ff82025ae526b5121bdbf6ad",
+    "cargo-1.54.0-x86_64-unknown-linux-musl": "d6e2d8e2075f433b3a607b95ef170a85fc0b44356905111004d23a9b72776b0a",
+    "cargo-1.55.0-aarch64-apple-darwin": "9e49c057f8020fa4f67e6530aa2929c175e5417d19fc9f3a14c9ffb168c2932d",
+    "cargo-1.55.0-aarch64-unknown-linux-gnu": "48bc8751f548b08643fbdea7756ccda35f0762492e95ea41ca41137290f56513",
+    "cargo-1.55.0-aarch64-unknown-linux-musl": "01ac6a21d74ac66a33e58d2d5766c4c90673be0e8385893da4e178a0ded56299",
+    "cargo-1.55.0-x86_64-apple-darwin": "4e004cb231c8efbd4241b012c6abeefc7d61e2b4357cfe69feb0d4a448d30f05",
+    "cargo-1.55.0-x86_64-pc-windows-msvc": "2bc59373437d25e5cb9d4f573fa187078c5a924a244366787ce04106d3972f6e",
+    "cargo-1.55.0-x86_64-unknown-freebsd": "f574b15dee6c52f25076bb657f3e3129b5828a2617c82f2e1c4101e0bd21a880",
+    "cargo-1.55.0-x86_64-unknown-linux-gnu": "bb18c74aea07fa29c7169ce78756dfd08c07da08c584874e09fa6929c8267ec1",
+    "cargo-1.55.0-x86_64-unknown-linux-musl": "d91efc8e7a71845dcec9ec7db1edb6765cba5ded69d3ab734f549d6875b52e97",
+    "cargo-1.56.0-aarch64-apple-darwin": "ced26df8edddcb7ebdedd2997b9005fc9a849e57b1b82f3aeba9241039f7b958",
+    "cargo-1.56.0-aarch64-unknown-linux-gnu": "3a3b0b74a18247db46badc1e94285fe5e60ad0e9c18fd2dbf15878aa56a5994a",
+    "cargo-1.56.0-aarch64-unknown-linux-musl": "bf24b7df97d93d61f6c1ed8382d99400c4197939502b14904c40ef96bb2abab5",
+    "cargo-1.56.0-x86_64-apple-darwin": "63b6558712050e7f8c57cac0b5b7cb2cafc125d157d9f4bd82f6f47b4648ed0d",
+    "cargo-1.56.0-x86_64-pc-windows-msvc": "319ae8cde721f611ddf673a4aad21b145aec6577ccb75d40ad0856cbab9a2cfe",
+    "cargo-1.56.0-x86_64-unknown-freebsd": "e1e7400a16c7cb1d2ac83e567c8c23f04fb6ccfcb7b6d1978d327da6edc879f6",
+    "cargo-1.56.0-x86_64-unknown-linux-gnu": "e74bd0038893e76393f67a58786ec33ef9251cdb65550b3a2a8117c7355ead71",
+    "cargo-1.56.0-x86_64-unknown-linux-musl": "efadb9f545b6ce49d4a861ae7e75f0ce02a6fedb9e5b30e7810dcb4854ca6799",
+    "cargo-1.56.1-aarch64-apple-darwin": "6ed30275214e956ee10b03db87b0b4297948fd102d39896cece01669555047ef",
+    "cargo-1.56.1-aarch64-unknown-linux-gnu": "9aa557436b0cf2a2f4f0d6c4aed5b95062c0637a4a94c000522402e59db1c93a",
+    "cargo-1.56.1-aarch64-unknown-linux-musl": "313f095df71bdd7cab5934641990cbcf325acdfefdcdf9d7a4a8aa950fc655d6",
+    "cargo-1.56.1-x86_64-apple-darwin": "cd60c32d0bb0ed59508df96bebb83cf6f85accb9908fb5d63ca95c983a190cf3",
+    "cargo-1.56.1-x86_64-pc-windows-msvc": "0606835d9c41137552ee63f339c5df1a2ed6f722c871f9fc5cb92b02c7372373",
+    "cargo-1.56.1-x86_64-unknown-freebsd": "a1656603049a4612cdf44179ac7ccdb3c342f0b152cb114f61a228d321b0f384",
+    "cargo-1.56.1-x86_64-unknown-linux-gnu": "c896c033bb1f430c4e200ae8af0f74d792e4909a458086b9597f076e1dcc2ab2",
+    "cargo-1.56.1-x86_64-unknown-linux-musl": "4ecdd39695d9e09c3f4efffff61d67451cd41f28f09155485ac7dcc8f7a65a26",
+    "cargo-1.57.0-aarch64-apple-darwin": "2171ecf2c18fadd90588252aa294272aeb740f065772076ef36d04b1b4bfcc4e",
+    "cargo-1.57.0-aarch64-unknown-linux-gnu": "8c046fc59feb1d670757b6de30990e346faa4b2ff49cd42f6d5f6a2b92a1ad6c",
+    "cargo-1.57.0-aarch64-unknown-linux-musl": "87f7b1fb2b1a270336fbeac0ed2ea2ceda1fde26467f133e059907b57ad2bdb6",
+    "cargo-1.57.0-x86_64-apple-darwin": "26129f0e3ecd42e730f62d9c693e1a89aedfe6b7c8108cf970b2f1ed51900fb8",
+    "cargo-1.57.0-x86_64-pc-windows-msvc": "23f4562605316f0c9002bb30d0e635f96577db9002052ef2f78b63e747b6b2cd",
+    "cargo-1.57.0-x86_64-unknown-freebsd": "c14839639299fce4e448629950c28de61fcfdd0393f9a751958c5c6d9c6d2ba7",
+    "cargo-1.57.0-x86_64-unknown-linux-gnu": "2b341034e4c30bede47a432751935549a28e40b566a1fd4b59c824ccd0a26ff6",
+    "cargo-1.57.0-x86_64-unknown-linux-musl": "0f14c6bb7c413c3be2db1917eb0109b7563bff0ba02a03d30089004811d87f2f",
+    "cargo-1.58.0-aarch64-apple-darwin": "9144ee0f614c8dcb5f34a774e47a24b676860fa442afda2a3c7f45abfe694e6a",
+    "cargo-1.58.0-aarch64-unknown-linux-gnu": "68e2e7493af55c5792636c2b2b0b497b1e43b12eb2e91da71e92426701884c24",
+    "cargo-1.58.0-aarch64-unknown-linux-musl": "269fd3730644890725b3affbf5ad97c3f1a186fcd22e7fc122b6b9b97388aaae",
+    "cargo-1.58.0-x86_64-apple-darwin": "60203fc7ec453f2a9eb93734c70a72f8ee88e349905edded04155c1646e283a6",
+    "cargo-1.58.0-x86_64-pc-windows-msvc": "ab0bdb95efa4084e19a706c14d826fa112306c25ec6304528dadff5f1017ab83",
+    "cargo-1.58.0-x86_64-unknown-freebsd": "8e280cfb6c7aa92d9c955fcfb80b6d09f067e779a5ca0b5799222f1a70ca4764",
+    "cargo-1.58.0-x86_64-unknown-linux-gnu": "940aa91ad2de39c18749e8d789d88846de2debbcf6207247225b42c6c3bf731a",
+    "cargo-1.58.0-x86_64-unknown-linux-musl": "926430f872e5a30b946bebe45df48ceb0d3dc8de04b35e295f33bb3b7dd394fe",
+    "cargo-1.58.1-aarch64-apple-darwin": "fe4507d345fea40e2157a6d7d69100c234a83b5904747ce976df577e63819134",
+    "cargo-1.58.1-aarch64-unknown-linux-gnu": "b4603fe8207c1ac2b5755a5f8da04c32a8a3d34ec1506df28de5dac9010350f1",
+    "cargo-1.58.1-aarch64-unknown-linux-musl": "1bf9187170e8cdaf52ddd45aa7c93248f4d8a6c730b20251cb182b57d6624bd0",
+    "cargo-1.58.1-x86_64-apple-darwin": "27087440329a7d3b0bd2b73870c76677e52c96390c3a7b76e151f8a86ce442be",
+    "cargo-1.58.1-x86_64-pc-windows-msvc": "4cbe75408c2745c72a27a37f77864745c7ce3e79c2d42708732c95fb3cbc9489",
+    "cargo-1.58.1-x86_64-unknown-freebsd": "f60d967c940400a92d142df1396a2031034374874a7575ad74bec2536e101fc4",
+    "cargo-1.58.1-x86_64-unknown-linux-gnu": "a6ca018e19eb25781b72e0ce9971be66c518adb6cebb0175ad88e6ff333f5118",
+    "cargo-1.58.1-x86_64-unknown-linux-musl": "45cca848155e2ef853de74329ee45948e4f6f28f797679d9070f4ffa767ef209",
+    "cargo-1.59.0-aarch64-apple-darwin": "4bdcb77ea084364b551a5cf969e263beb09afa39627f6dead262c8e2a7aed9c1",
+    "cargo-1.59.0-aarch64-unknown-linux-gnu": "857d0b4afa76773a68ebe616db01d1b97d24b6d02b55e7348c968aa48104793b",
+    "cargo-1.59.0-aarch64-unknown-linux-musl": "89ea1001d79ac7dc2158950c40a73aca6d1177d5e44562e9e5a8656b916e344c",
+    "cargo-1.59.0-x86_64-apple-darwin": "d0202b50b4f3d0e943a5d7e8d14420afeac8cf36e6136e8d5b7ddefb3538d62a",
+    "cargo-1.59.0-x86_64-pc-windows-msvc": "4cf585f1a3b295f6d51873c189c2b9d114861a4b41b44ad5245cbf119272a6f2",
+    "cargo-1.59.0-x86_64-unknown-freebsd": "a6732b18419efb4d246a35555f4ccbf904de261cde02f8e82fdbef67e70ddf80",
+    "cargo-1.59.0-x86_64-unknown-linux-gnu": "703c1c66f1d68549d1ee0b7a96f91935a3583af8ec13cc1722ff7a0f1c69ca70",
+    "cargo-1.59.0-x86_64-unknown-linux-musl": "ee2fa67e67395f9b8e1b52433ca281454c3e4f55db536414edfadfa2d649c8bf",
+    "clippy-1.48.0-aarch64-unknown-linux-gnu": "2cc894bf75d938c0f7b96c7711d93b6d5a0befed5c09232cdd8413a57942ed88",
+    "clippy-1.48.0-aarch64-unknown-linux-musl": "b3d740358470df6f4c1881a40db16c6fce4082bd251b012963147fdadab96879",
+    "clippy-1.48.0-x86_64-apple-darwin": "d70a5d224a90df3fc77d7bd38df931023a3966be755b888bf0888d6bfcbdc424",
+    "clippy-1.48.0-x86_64-pc-windows-msvc": "e52103f31fe8d4e067b28273ba0aed9ae352d88ad1c3b9860ec1e08b81241ebc",
+    "clippy-1.48.0-x86_64-unknown-freebsd": "14459e9629b09c83c38fe2366d996490c1691fb3ae9937f4a8de48219857e14a",
+    "clippy-1.48.0-x86_64-unknown-linux-gnu": "409c2e4a6b50f9a797379e687c2d0bcbda4a268e736fadd2be07f35a2fb9557f",
+    "clippy-1.48.0-x86_64-unknown-linux-musl": "cf6480cc206ef4b615f95de2f048e6bbf17072b39dd76246faf3440fccea3704",
+    "clippy-1.49.0-aarch64-apple-darwin": "d6f2782d600f1a25d1fb9fe828be0cf170fe5afad50184c30e8c32310f26fd8c",
+    "clippy-1.49.0-aarch64-unknown-linux-gnu": "ed805952ab975e9f395fa68544448ff7a6e823c4bf7e04952e4c1dae5a550be3",
+    "clippy-1.49.0-aarch64-unknown-linux-musl": "f4329c16a6f448abe7be50b2206ca7d8a21605d9d8e3f01303fbe737d0c3bf7a",
+    "clippy-1.49.0-x86_64-apple-darwin": "c4a7baeda3a558a65af3afe857aedb5f25e8dd0ba42ea02cdd1056d92e610b35",
+    "clippy-1.49.0-x86_64-pc-windows-msvc": "70eec30a80aebaa1f6f4dfc1a6fa681cdc833aa2281726319a06c9fb1af277fa",
+    "clippy-1.49.0-x86_64-unknown-freebsd": "835bb7c1d4f4d57453f69b35e758347ad02f22949cbce3265282d2059aea4166",
+    "clippy-1.49.0-x86_64-unknown-linux-gnu": "0be34ad7ddde82f54353d5322c6142b43d4dee54ea26b9428a3a34444aa4b9c4",
+    "clippy-1.49.0-x86_64-unknown-linux-musl": "c53a5e73e99ea9f3e14f2c1164f234eac4e60e428ed82502ffbfdd19be728f3f",
+    "clippy-1.50.0-aarch64-apple-darwin": "c0a335e4cc3b0775661c98937c767eb63f5cca4a8a224c164af2415158175025",
+    "clippy-1.50.0-aarch64-unknown-linux-gnu": "bfdd830f04b1dae6ffa71e750b391cdd43def5a9c266366eea8e6b8071509747",
+    "clippy-1.50.0-aarch64-unknown-linux-musl": "1fb4eaf6c2230ff138edb906ac55fbb47b638e412c83580a783749a38096cb98",
+    "clippy-1.50.0-x86_64-apple-darwin": "466be411c4eff28c006179ba5a45af5c37dc9a56395a24ad597fa54a475eb97e",
+    "clippy-1.50.0-x86_64-pc-windows-msvc": "65b3198dc0082d2ca77559047901dd102d100bf7fde513a0a3e81ab78c93d568",
+    "clippy-1.50.0-x86_64-unknown-freebsd": "f065a60cae99287eeed1ad479f159efeef7f79459b8b4369c451d966bc8b0bed",
+    "clippy-1.50.0-x86_64-unknown-linux-gnu": "ef4098fdb39d67366300a63370c513ca97fdce8f4d6ce9e2a5fbff32d3a8ea38",
+    "clippy-1.50.0-x86_64-unknown-linux-musl": "b921d64ab3a130240372c069f72b549ec5c0d566dd302c6b7593453536688ed9",
+    "clippy-1.51.0-aarch64-apple-darwin": "1d4769e522ec3275b6a1b6e63f0d48b6995cf3647df4d97fc1c20bf2969cac6d",
+    "clippy-1.51.0-aarch64-unknown-linux-gnu": "bbf4f53e8c9496524384cf8e3a9e56bd80b19aae12135c058ef113bec40fd30e",
+    "clippy-1.51.0-aarch64-unknown-linux-musl": "ede6e08307a91fb18feec8d4ea9e170dd3f522f79267ca39d258dd554af5eef0",
+    "clippy-1.51.0-x86_64-apple-darwin": "6c1d2c143720058a67da274b1579b4e7e955bd35de6d4714d884b55030ead225",
+    "clippy-1.51.0-x86_64-pc-windows-msvc": "9d7c25c031257ec62b0800e418252e4a53319a513deb9e682b438bef1abc4056",
+    "clippy-1.51.0-x86_64-unknown-freebsd": "db15a34b5d829338f63c436665c7106817b2577d9417615d75e4aa6b27633c3a",
+    "clippy-1.51.0-x86_64-unknown-linux-gnu": "61774912e775de826e4f9173c8f91a915d91319d353ecad46361775a035ed69f",
+    "clippy-1.51.0-x86_64-unknown-linux-musl": "4d3f51f4e1220e740e6d310c5f90652b8463e8897a9e4fe82d9c4b8e3315f9b5",
+    "clippy-1.52.0-aarch64-apple-darwin": "0e8a71e8567553ed625168f46e2253c04ef19f0ae7683b6500b3fc07cb81fefb",
+    "clippy-1.52.0-aarch64-unknown-linux-gnu": "06b0a9e579b93bcf5948f013c1e053f8ad6717b3349068b2dbe774215f4b0dd3",
+    "clippy-1.52.0-aarch64-unknown-linux-musl": "a2075592aeb37ad33ebcd93b228e79dabd8fb62eeee7aae531ac0d9682eb6abc",
+    "clippy-1.52.0-x86_64-apple-darwin": "baef3bd3c93872c67ddede8b657236f5f368a9e30b2ba9725c70881877c6db28",
+    "clippy-1.52.0-x86_64-pc-windows-msvc": "149418af4a93f3c4d8978eccf95a968d2fcef4cdd748b284c782d8efd06d38da",
+    "clippy-1.52.0-x86_64-unknown-freebsd": "db50b6ac0cfb3c8eca34e8059014bd5602dfd160246a51efef568165ff7bd4bc",
+    "clippy-1.52.0-x86_64-unknown-linux-gnu": "00a55613d1a47c12c08f6b101ca791052b07650b624c102acdda4569ba2652a9",
+    "clippy-1.52.0-x86_64-unknown-linux-musl": "95950b2455e706d500a2c2f02904e5d48394b998f5f486fe376a144edcd7f85b",
+    "clippy-1.52.1-aarch64-apple-darwin": "fa19b0115201c9462f36eb8f51db07cf58af02ba2c997f1431719f78bea30904",
+    "clippy-1.52.1-aarch64-unknown-linux-gnu": "91d914a83b5c6d1b551a4acfa96c9cd4365b674438fdd3d2114ee86f11f53849",
+    "clippy-1.52.1-aarch64-unknown-linux-musl": "0910ba13838bf80b5ae86c219078340fc02ba5e0b570c54a510aedf78cc6837d",
+    "clippy-1.52.1-x86_64-apple-darwin": "39264348d1246a9cff623eb511979b71831ff331e16be6bf3371ccefa19a23f5",
+    "clippy-1.52.1-x86_64-pc-windows-msvc": "2470d52eda90cd6f7a02901bb2144c40957b0decf2af8f6cf115265acc64c956",
+    "clippy-1.52.1-x86_64-unknown-freebsd": "d9b4aeb263668e95b3fff8d4125ce28905695c1c8ed3d9d5bf949d47d386d13c",
+    "clippy-1.52.1-x86_64-unknown-linux-gnu": "33d6d2446ec4d381057f404c7081686856a001bd91409d81c96aeeb6c452d289",
+    "clippy-1.52.1-x86_64-unknown-linux-musl": "f37ccdaf359f1ae4aa31324490a9ab2ebfe56e5f11245dfea04930eaa0b5c5c3",
+    "clippy-1.53.0-aarch64-apple-darwin": "311247f7aabd4d846d1220f26a6ea6478219d6549a9abc546ad69092dde2e1a7",
+    "clippy-1.53.0-aarch64-unknown-linux-gnu": "56842a410a38293a09cf4d880a5d237c10eaf8344a080bb1ea0d3e069ce12112",
+    "clippy-1.53.0-aarch64-unknown-linux-musl": "26db11ca69b33b3ac8e3379573f7e3bbc352f7920f98c4434465636c34d386dc",
+    "clippy-1.53.0-x86_64-apple-darwin": "ede5bceff1be27a21b12a3be4034d254925d3d58d39713fa4af9fa561f1ea671",
+    "clippy-1.53.0-x86_64-pc-windows-msvc": "dcff1fcdae5ca816a71c9f080246860e8e1d90022576d28d74d033f940ed8aa5",
+    "clippy-1.53.0-x86_64-unknown-freebsd": "4de1e957c3999a130ef3cb0362a28746ffaf79197cbb1ebabf7be6be115b2f29",
+    "clippy-1.53.0-x86_64-unknown-linux-gnu": "bf065f9c7710a5e7305fb511bd1e21bd248ab216230ec0c71d8bdd2383e0b088",
+    "clippy-1.53.0-x86_64-unknown-linux-musl": "ae84cd0677a5446dd07384d4006f52fc6e2d290728edabb5a169a56ca9bb388b",
+    "clippy-1.54.0-aarch64-apple-darwin": "086e52350792a8b4e3f3f40753948e7d067c38c9c0f22492f2c7d88ba7c94e95",
+    "clippy-1.54.0-aarch64-unknown-linux-gnu": "e25bdd281f3fa9cb194eaefe75cea7f4f0cd70c615ac7077a015764360d45953",
+    "clippy-1.54.0-aarch64-unknown-linux-musl": "8de3e94808e40540402aafed1343ce6cd058c86fa7ac174c6ec591e4a03d6c09",
+    "clippy-1.54.0-x86_64-apple-darwin": "b1548c2d6d524aad02865e98a367dc665cd5b1847a20d29b142cc13adfea43b8",
+    "clippy-1.54.0-x86_64-pc-windows-msvc": "36e03f67f45d83d66187df2380b4acaaa2cfe5924c53c724a83a2780f78212a1",
+    "clippy-1.54.0-x86_64-unknown-freebsd": "92569c0f9faab4501d47ab6958d6535d2039490e763cc65c1700b0c5436106b0",
+    "clippy-1.54.0-x86_64-unknown-linux-gnu": "4896d754064c781611901c459d326dfcc10d9916cad5c1dd6a0898bca7e6428e",
+    "clippy-1.54.0-x86_64-unknown-linux-musl": "8184892daa7b652af96c9634ad15f33e97b022c7aad16e1e95bb95bf3fa96972",
+    "clippy-1.55.0-aarch64-apple-darwin": "470c8c99050a7785c4b261ab95575141bb48f19dc135dec96b8424e175898670",
+    "clippy-1.55.0-aarch64-unknown-linux-gnu": "ace2cface85e199c5d1773a88ca5ba4d1527cf3936bc844113e4defb54fc13b8",
+    "clippy-1.55.0-aarch64-unknown-linux-musl": "f1dead08b21cc8a67a3d27c785e107d2aa5363e60dcfd74c7fb81fd663d288b8",
+    "clippy-1.55.0-x86_64-apple-darwin": "fff5969a2a6795e28e040eda2ab59d29a48ff5aad0f15bea194b61befbffec77",
+    "clippy-1.55.0-x86_64-pc-windows-msvc": "d7dfa77cc50348023d973311bf378181bdf18d5aff7c2fde69cf8031564667da",
+    "clippy-1.55.0-x86_64-unknown-freebsd": "ba035cd7f62468fc75a56f604ac3579adce4f90ba2e6df219299f21668def51f",
+    "clippy-1.55.0-x86_64-unknown-linux-gnu": "108ebbc6b311fc0cafc125f1fd7f35a82935000c60cad49a565958e47f63193f",
+    "clippy-1.55.0-x86_64-unknown-linux-musl": "e248a8b3987c2750439966ed5df385a089147079105d85041a8147b1044b4f3c",
+    "clippy-1.56.0-aarch64-apple-darwin": "70eb9ec3d9ab79c20030bd0df903ff972dea451dd2a4b55c7eaa8837c1782071",
+    "clippy-1.56.0-aarch64-unknown-linux-gnu": "fb62502c82cf35fecc55761fb3f7a816d2d355cb31ad89fa844be4a1368853de",
+    "clippy-1.56.0-aarch64-unknown-linux-musl": "fb1852dbeff93f1518ae3d0f7adfeb95596aa55069ad24dbcda14e59bd9ec9a2",
+    "clippy-1.56.0-x86_64-apple-darwin": "9410b2f7096ecc3f495fc8a36e14bd566fdd3e6fda2923b4732c3055da81fcf7",
+    "clippy-1.56.0-x86_64-pc-windows-msvc": "cdca7f40793889dca4eb19b846c7ca7bc60ffd8f5cc2fa20c6c71b66c26e9449",
+    "clippy-1.56.0-x86_64-unknown-freebsd": "c5751a4a7043c7a29755459193cde2a1468b4a0726fb3b188853afc6d6870510",
+    "clippy-1.56.0-x86_64-unknown-linux-gnu": "52b49ecc5d44d7f83983ad1aaa37ed9d0ac86a72395cef9e31d06f4ba2343c03",
+    "clippy-1.56.0-x86_64-unknown-linux-musl": "32b7b596225dedf38f9228edd1fde9211f6bd1969f924c3de7cc0d5150577487",
+    "clippy-1.56.1-aarch64-apple-darwin": "a3ea45a2c569bbfabe556c6d3c3ca6caa3aa84cd1c4897027a7ae17856ad9c9c",
+    "clippy-1.56.1-aarch64-unknown-linux-gnu": "2b9bea99c887b07b960325f51989600c120278ba658ada17ca9b9f8c75270265",
+    "clippy-1.56.1-aarch64-unknown-linux-musl": "578aeb964a07730e8f92b360e7e96c89728ff35d9d2bd21b1e7436b06960b0a6",
+    "clippy-1.56.1-x86_64-apple-darwin": "00690eb127e30b75992256481e75d4f3dd6afcedd0d00495eee88137cdbfc6a9",
+    "clippy-1.56.1-x86_64-pc-windows-msvc": "932cb41989bb9f72c1a8c37a306a663d311fba26e34f3759e3fe533c963c1571",
+    "clippy-1.56.1-x86_64-unknown-freebsd": "2e25fdf46fb4144115583cc2ee9a43d9d8a5ee8806a00ed676c89ab3f26ff799",
+    "clippy-1.56.1-x86_64-unknown-linux-gnu": "07bfe461a7da0631917a1c2ff0f319af85d1083ada911a089a76e792cf673d16",
+    "clippy-1.56.1-x86_64-unknown-linux-musl": "031f5118516ee442d9489ac32922cfa322b76629ba2dbcbd10047891651e8955",
+    "clippy-1.57.0-aarch64-apple-darwin": "1e29be461daed9196ffeabca4855501de118a503863f54873cb24b18ffb785ce",
+    "clippy-1.57.0-aarch64-unknown-linux-gnu": "c6f082eeb70580e293feb68a0bf415d8e490675a50e66c67384cbbf2c38539e2",
+    "clippy-1.57.0-aarch64-unknown-linux-musl": "f8ec644a01ef3f69db2b90e91640334de4b5b557ff2a085053e937f12d428f14",
+    "clippy-1.57.0-x86_64-apple-darwin": "f232a98a50cc0cb6237a09e59e12bf0ed67051e369d5371519085f91f7bd9411",
+    "clippy-1.57.0-x86_64-pc-windows-msvc": "e24ba652942e85bba965b61045f0515f4c7f3537eeea6ae7023c2110179545d5",
+    "clippy-1.57.0-x86_64-unknown-freebsd": "664d64fa5557717b7ea14fb3dfa8c7a32fc03296ff6ea38243e42dbb371776b7",
+    "clippy-1.57.0-x86_64-unknown-linux-gnu": "650a417e4adb00c29795110fb07d671e8fe79ef54a682a357defe7b402d09838",
+    "clippy-1.57.0-x86_64-unknown-linux-musl": "ba8eb172cc6435e396312509925058af6bc16ddd6da8abca7a89b8dbf4dd32d3",
+    "clippy-1.58.0-aarch64-apple-darwin": "8370af0cb5e274de23adab83eb62ce32bf117dfe4681a731719d2b3d1a9758b9",
+    "clippy-1.58.0-aarch64-unknown-linux-gnu": "d228ee69d7552d66f637d0afed4d43098fe0b87fc4cd15ff670f06aec642e171",
+    "clippy-1.58.0-aarch64-unknown-linux-musl": "5dd6ae5262d0b02f417d37698e9ed72a44880cf389e6ca4c2ad6fdcddbc87e3d",
+    "clippy-1.58.0-x86_64-apple-darwin": "98489c63d307db213c66d18f375c4feca49eaca1a48967d0b13e5395a1564924",
+    "clippy-1.58.0-x86_64-pc-windows-msvc": "52ca3e4cf88a39ed02aa573de29a88868b5bf326c4d148b12b791071d004c79a",
+    "clippy-1.58.0-x86_64-unknown-freebsd": "801695120c015e84980408fce40ce0797c7720c291a7d8b56ca0a642d133d336",
+    "clippy-1.58.0-x86_64-unknown-linux-gnu": "747524e25f22659447bef677083625657caa2138a945d44998eb375b4262f9c7",
+    "clippy-1.58.0-x86_64-unknown-linux-musl": "dd4bb678e1f48e6013b46e350355a4911dbef865d23613cb950cfe3691cae88c",
+    "clippy-1.58.1-aarch64-apple-darwin": "89e881ec4e8e2a54cef8999fc85bfec72fc749f4bf3eb292d0b6b7318652992b",
+    "clippy-1.58.1-aarch64-unknown-linux-gnu": "efc65bf92fc1011dc34805d6b2ae18ecebd85f9593fc4dffd9dd1e59daf6eb6a",
+    "clippy-1.58.1-aarch64-unknown-linux-musl": "d28e4e64aa8b96dea036165481ba0b3df118edad7cead3902b1bfe5becf0dd33",
+    "clippy-1.58.1-x86_64-apple-darwin": "e5a67b36bec6c0ba128f134fd08621a6a72b08db64020592b171ea66a1af300d",
+    "clippy-1.58.1-x86_64-pc-windows-msvc": "ee3186a2fe0dd68cfc4d63771d5cb67fd7c34bffcf8bc60fc7f0e70e0c37e94e",
+    "clippy-1.58.1-x86_64-unknown-freebsd": "e52bdea9a882c610b4510011f36b359df5dd0c6b33e3e6c7c1ea1336b59774e9",
+    "clippy-1.58.1-x86_64-unknown-linux-gnu": "8a750e67626799c6d7c2424f5ba47c9d9d4aa128bc2f7b78f9bedb8e4e8c46a3",
+    "clippy-1.58.1-x86_64-unknown-linux-musl": "74ee750364731d8a1f67a7dda33381e64f07adb8af782a5fd00f1b8b5f09b083",
+    "clippy-1.59.0-aarch64-apple-darwin": "37e2589cb182da7c7878eac4386973ee0539e11de6cea047d500247e57214573",
+    "clippy-1.59.0-aarch64-unknown-linux-gnu": "d4278d73c317d487ea4cdfbaf43ffe048744c0ce887c584eb396016b9cc007af",
+    "clippy-1.59.0-aarch64-unknown-linux-musl": "9f8e96d61a23c83cc59c44bac7b42b997f173974ee8b6cd4a9c3b4a54caa0107",
+    "clippy-1.59.0-x86_64-apple-darwin": "932e843d538f3775d7996ad2f9a4e412f431d413c6585521fc95dba85aca2bad",
+    "clippy-1.59.0-x86_64-pc-windows-msvc": "786751cdc3b1937c19e555255092c888509e81ab6295887da0e92f1de7f5900d",
+    "clippy-1.59.0-x86_64-unknown-freebsd": "d1c2ab40e6be423d4d4e29af85b56dec090cc49afb82684c07b0cb19317d043b",
+    "clippy-1.59.0-x86_64-unknown-linux-gnu": "aad54aae93bd8cad8fa1ae77a0e4f79b8439d471b1478a0fb67294497a782edb",
+    "clippy-1.59.0-x86_64-unknown-linux-musl": "23b57a9b3b30b6724df278860d9700e50e88b5dff5afd8b8ddaf0bf235695762",
+    "llvm-tools-1.36.0-aarch64-unknown-linux-gnu": "942856e49837a1c3b9c7d48b52cf0ac0fcb2bb31bb691fe53bfb934afb561c7f",
+    "llvm-tools-1.36.0-x86_64-apple-darwin": "ed702a4174a27fcf118f301e79835c3da205d3d98adb4acc294b72293a2ec790",
+    "llvm-tools-1.36.0-x86_64-pc-windows-msvc": "cf72242bcf873227c026505f56f3ffdaa2febde828d67ad7fc04c4a2e72d7587",
+    "llvm-tools-1.36.0-x86_64-unknown-freebsd": "37c19db740acbe462d878fe193b59653a5073b23a840c6a2e2924772c0642b56",
+    "llvm-tools-1.36.0-x86_64-unknown-linux-gnu": "beae1690418b4adffac166fbfde525be8f5e2b2ce220ffd19b420edb1efa4477",
+    "llvm-tools-1.36.0-x86_64-unknown-linux-musl": "6f2754a2305792e3160fe3d1710e8609b242fbe753b8b18867acf6f3d326dc95",
+    "llvm-tools-1.37.0-aarch64-unknown-linux-gnu": "fb7cea148816422466aee656d81b08f9cb819cff8c431574f08c281b58547413",
+    "llvm-tools-1.37.0-x86_64-apple-darwin": "b882607b0f181d3942eb00a13cb375d820d000ced456a0cfd626ad79f597f8ac",
+    "llvm-tools-1.37.0-x86_64-pc-windows-msvc": "804a1455879b72f9439e9f2d6469f328847ccb432f69b41ccbad2ecc0e124fb2",
+    "llvm-tools-1.37.0-x86_64-unknown-freebsd": "206bf31dc2851a27b697acd5ad978d2b0d1cfdf26e01b7798388030591fa7899",
+    "llvm-tools-1.37.0-x86_64-unknown-linux-gnu": "da54ade6c7e2776edab1b6f1216477168cadf30fe40e503cca8b4bce20d89bc6",
+    "llvm-tools-1.37.0-x86_64-unknown-linux-musl": "737f6f903340700c7953c46f3143418d90f8bc1f879cd940ce0bcc479109b7d4",
+    "llvm-tools-1.38.0-aarch64-unknown-linux-gnu": "dbbfdc0dd802feb94e8e0f0eb0dad2c2f3e6bf69bb58d371622c94e8c7e82e25",
+    "llvm-tools-1.38.0-x86_64-apple-darwin": "7a4f8502b93e6fc3a4d89ab94230a90c94778d17badcdde25ebb545f4e37a7c0",
+    "llvm-tools-1.38.0-x86_64-pc-windows-msvc": "da005a040ee70728c224eb23d1374420422ac64e2b4ba328ac6d7b5934389061",
+    "llvm-tools-1.38.0-x86_64-unknown-freebsd": "f4da25e84e31a78b6f761b3f597c98391bd6873298c7708dc886b2c72f56f874",
+    "llvm-tools-1.38.0-x86_64-unknown-linux-gnu": "0fff5bc69ebf49fec0372aa73f9b6757b8a6bb506f14f48d153e6f14de2fd19a",
+    "llvm-tools-1.38.0-x86_64-unknown-linux-musl": "5877d995125b6d17f25f23f9eaccb5775dc2bde5f3b7062fff8cad23221e80e8",
+    "llvm-tools-1.39.0-aarch64-unknown-linux-gnu": "9c7eae2e5770d20872f6012b273d2ca5dab09f97f497a0cc82ea5af8e2b08527",
+    "llvm-tools-1.39.0-x86_64-apple-darwin": "52c15480345a18d55a2141a9f440fe874a8686d3d94e4637b2c4884df7c88a43",
+    "llvm-tools-1.39.0-x86_64-pc-windows-msvc": "87b7cf10ebab53bb7fab625d603f80e35111afaeacd915df63c19ad68382f31f",
+    "llvm-tools-1.39.0-x86_64-unknown-freebsd": "f451ffb87b00a277264c5acf5267f8df61300089a9798607b4cdfebc88fabee1",
+    "llvm-tools-1.39.0-x86_64-unknown-linux-gnu": "0a87b543e3841d415887a4543587b783fce678a7097a774a56a2032cee842991",
+    "llvm-tools-1.39.0-x86_64-unknown-linux-musl": "da87e08670b7dad359f3d0b3f132d212713dcb21cf1c5e308acf257632de0075",
+    "llvm-tools-1.40.0-aarch64-unknown-linux-gnu": "caf36148d0f5a885cad05605d80cc2c805ce8456837b6dbb34b47420a4d52475",
+    "llvm-tools-1.40.0-x86_64-apple-darwin": "d4c4abb2a7b2800500ef4e0a46493c5340bb7b0be84d38897573281e93b8577f",
+    "llvm-tools-1.40.0-x86_64-pc-windows-msvc": "0fe4cfa0e4ce99e45c810b8301edcdfa694db75e291b497ce8c52ec5b89e4861",
+    "llvm-tools-1.40.0-x86_64-unknown-freebsd": "aa11c881fa728fa8df233c220fecd6b25cb27cbb673569cbd9a90865ae464d9f",
+    "llvm-tools-1.40.0-x86_64-unknown-linux-gnu": "40c5ad2c53802b8b722ebd5a06b9f51f32644d8a6d6fdc32aacc60a33bed5839",
+    "llvm-tools-1.40.0-x86_64-unknown-linux-musl": "8e98e884442ade699f951bdab603a012c683de5809cae6bcb25bdc81abc3c4db",
+    "llvm-tools-1.41.0-aarch64-unknown-linux-gnu": "279aedca8c3c12a0608de9a51fa38a33b910600e4f980487c1706cec29270c63",
+    "llvm-tools-1.41.0-x86_64-apple-darwin": "621676b4ae3d75662463876315a58bd188ceb4b22ff249ad033e0181fe30df74",
+    "llvm-tools-1.41.0-x86_64-pc-windows-msvc": "6d1b3a2a74497b0a4e9420d87a6fa462dc608a3b41d4dae9f164cf66c290a00d",
+    "llvm-tools-1.41.0-x86_64-unknown-freebsd": "311a056371edbad2194b5714f3e8d17e7a897f27b67bdbe2d827ed437d06d050",
+    "llvm-tools-1.41.0-x86_64-unknown-linux-gnu": "d2cfa10a162cd9b63c5b8eb3db49560532c11823bb15f836abc5e42cca1a1170",
+    "llvm-tools-1.41.0-x86_64-unknown-linux-musl": "dd176d66f6f04d2e1c0deeb11d07d5882937af6c72121cad4bc7e63bba3fa0ff",
+    "llvm-tools-1.42.0-aarch64-unknown-linux-gnu": "7601ef92b42a321fee08f6adce3ca0eb612ca8703fda1db63e30bd4952f7fcc9",
+    "llvm-tools-1.42.0-x86_64-apple-darwin": "c4c0319e8be687b104162ce3654249ed76040229a77d77016e32570fbfbd3439",
+    "llvm-tools-1.42.0-x86_64-pc-windows-msvc": "721b14d159d6df877991db62a0f5fcd11d8d9cd642d8f51311a2d2c99c0f9e43",
+    "llvm-tools-1.42.0-x86_64-unknown-freebsd": "4fc2bb1ab454b21750c78f9ce19d7138e4929a804770202319a3f457b1e5c2f9",
+    "llvm-tools-1.42.0-x86_64-unknown-linux-gnu": "d306ee9009eeab2062b813123628cc440f58c71c0e1d53afe1563f4eb1a5e0e4",
+    "llvm-tools-1.42.0-x86_64-unknown-linux-musl": "7fc21cc7f2a8879b052fed92fedff55df5afd528912c8405ec67640f663d716e",
+    "llvm-tools-1.43.0-aarch64-unknown-linux-gnu": "647dc36be8dc5130a703f6ba151bc79936503d0251481ba40bfacc5bfa251947",
+    "llvm-tools-1.43.0-x86_64-apple-darwin": "890bf12d80b72fc0c58966e1d229cfb24764eabe356762dcaf126afbd63fd47d",
+    "llvm-tools-1.43.0-x86_64-pc-windows-msvc": "e299dea627f89f6b14897d45f39dba3036298b2c94f35ba4dfea276996682977",
+    "llvm-tools-1.43.0-x86_64-unknown-freebsd": "6a64cc4b3dd0b8218b350b4fad36197edf2da33e5ab43c4670737e4d392ba586",
+    "llvm-tools-1.43.0-x86_64-unknown-linux-gnu": "4f62cab67e89d78d886cb03379d71f6722f8c5e5c069b3c243e334381c5948cf",
+    "llvm-tools-1.43.0-x86_64-unknown-linux-musl": "ea90e9540b5618698088171793dc571614d434571d6c81a80259a597d536a265",
+    "llvm-tools-1.44.0-aarch64-unknown-linux-gnu": "e25ee71a187d6c8969b17788fb678c9b358034ad2a2fb7557b755534eaf9cfa6",
+    "llvm-tools-1.44.0-x86_64-apple-darwin": "d684de7783ee15537f78231acacb9079f821c8c8b85b889e54c40b095ae6b0a1",
+    "llvm-tools-1.44.0-x86_64-pc-windows-msvc": "ac84fcc25d5d8d20592d6491576df7a72059fe9317889692badac2fc9028bd8a",
+    "llvm-tools-1.44.0-x86_64-unknown-freebsd": "3f4a17239b9dc9e84d98922ea4725f741249ba597ac1345b09c818b54b7a0765",
+    "llvm-tools-1.44.0-x86_64-unknown-linux-gnu": "1755b589718c652071e354c3629f41a9a90a84a3649078ed697e630ba19b3592",
+    "llvm-tools-1.44.0-x86_64-unknown-linux-musl": "c3abf2adba70a8cce16e4a6962b6868238858e54c9822cec64c5f981e43489b8",
+    "llvm-tools-1.45.0-aarch64-unknown-linux-gnu": "1432bf52b301e16a5a57398a7f59bcee43358913627c7caf7b1568cd8824c5c4",
+    "llvm-tools-1.45.0-x86_64-apple-darwin": "9c4e5488be910b8b5ded830ea4c8844090801d3f35e7d9cb1f272e3e7df90a0d",
+    "llvm-tools-1.45.0-x86_64-pc-windows-msvc": "5a2b5f49e04def6bc6bdb148412bf62ca7fd01d0e8ed61d07fe6716003425350",
+    "llvm-tools-1.45.0-x86_64-unknown-freebsd": "dbeaa09b90aab06a8450afaa9018a859a440be48d98e9437a7d827a138d3ae7a",
+    "llvm-tools-1.45.0-x86_64-unknown-linux-gnu": "54a2ac31ad53d3d346c571fa1d25b730b614a8214b5484c511f21f7dd0bdbd5f",
+    "llvm-tools-1.45.0-x86_64-unknown-linux-musl": "5e610db342edfb61ac702b36eebb4cfa1a4d2c0b89ca400b2ca89055167e07fc",
+    "llvm-tools-1.46.0-aarch64-unknown-linux-gnu": "1d8107ff0682d20c37a0d42f54fa1e2e96e70f7c4694fc71a84f7b32e3793247",
+    "llvm-tools-1.46.0-x86_64-apple-darwin": "1045f55a6e59326e0f5b46616e8c945f0cc04c4519f21aa095f87b3e35420422",
+    "llvm-tools-1.46.0-x86_64-pc-windows-msvc": "037719e7774bae1e3084949123a8a10d4d2c89134849333a53c7dcad00fe412e",
+    "llvm-tools-1.46.0-x86_64-unknown-freebsd": "55d9194cd9ac3f26f95f4f94db899c86b140753ef57aa2996dd8be528eaf8ae0",
+    "llvm-tools-1.46.0-x86_64-unknown-linux-gnu": "2a98e7290148575cdc6230610fca3ce68d1bd7b7dd105124f8a1673859ecc9ad",
+    "llvm-tools-1.46.0-x86_64-unknown-linux-musl": "431339bdd829224c0d3a3c835d65de95e52f042c1e0c3a286718055af4b2b977",
+    "llvm-tools-1.47.0-aarch64-unknown-linux-gnu": "6f9cc27ea4d33ef81be176392d169a2ca2ba6d3e6e8c037917133823cc4979c1",
+    "llvm-tools-1.47.0-x86_64-apple-darwin": "75a8381f7f521ad8afc8480e2bda27d3d3730b9ee154022deb26db3ca6216505",
+    "llvm-tools-1.47.0-x86_64-pc-windows-msvc": "e9a5d9db6f899904f094cc745a1b5cc47f7d7bbcb708217ad68933316e814880",
+    "llvm-tools-1.47.0-x86_64-unknown-freebsd": "47592da88536cf5c44085907c7e5d57bf695d5ac8add76d2c7d1c0518e6e05e6",
+    "llvm-tools-1.47.0-x86_64-unknown-linux-gnu": "a52c3cd18a6895c91a49d0a00f2cb4b12d64dd5b1ef6607fade1fed88fc36dac",
+    "llvm-tools-1.47.0-x86_64-unknown-linux-musl": "08ec337e44c1d83438d84e79dfacf6f123a8ed1af90c8130da784ded74966187",
+    "llvm-tools-1.48.0-aarch64-unknown-linux-gnu": "133e6b94d3c34d91ea9689c9288c66acf169d59877c0c924fc99b1fee283f4f4",
+    "llvm-tools-1.48.0-aarch64-unknown-linux-musl": "5a643eb72e06c4baa68ab38481b0e24ad40468e07dced9dfade04f469cce3b26",
+    "llvm-tools-1.48.0-x86_64-apple-darwin": "de0715d6cb0456da647750605ea1a3e3832278a4fa500d9c13bd148e7b278afe",
+    "llvm-tools-1.48.0-x86_64-pc-windows-msvc": "a0506c1619708e2bdf6bc198db5d130965613ec0609a9fe75556ce5effdf4f78",
+    "llvm-tools-1.48.0-x86_64-unknown-freebsd": "61a56f1436c7e4bfe68be160abb61989a8b4b4fef5e939764d488587484d6da3",
+    "llvm-tools-1.48.0-x86_64-unknown-linux-gnu": "a4932dafdc84a2c2f4f67a9aa207ce306c36a4ed8e682e6d79764d438ebd00b8",
+    "llvm-tools-1.48.0-x86_64-unknown-linux-musl": "904e1a0009819b626bd643cfe7f82d8de7e277e69aa0791de26fb3754d897046",
+    "llvm-tools-1.49.0-aarch64-apple-darwin": "78f666e9608c6b38f704447ef270170154c55dcda033e4fab00c42bebc3319a5",
+    "llvm-tools-1.49.0-aarch64-unknown-linux-gnu": "50228dd0c1ea9f483cac055fd1ff82f202427ef970266e904be01133c40f0c91",
+    "llvm-tools-1.49.0-aarch64-unknown-linux-musl": "0992328492832f96f4ee35661d8706e8e5f630bb92de117398f0b27556bc98cd",
+    "llvm-tools-1.49.0-x86_64-apple-darwin": "39c294fb87e6dc8c29975469a0566d4f8a47e50c1defe9f3dabbf1d598772bea",
+    "llvm-tools-1.49.0-x86_64-pc-windows-msvc": "3e57ff66c2a0091e3373e479fec699d3012e9249b7e0da36500fa0071308114f",
+    "llvm-tools-1.49.0-x86_64-unknown-freebsd": "c2b3c06bf4b2f6010f9927391c8e72f96642a528c486ec98f66c16066298e015",
+    "llvm-tools-1.49.0-x86_64-unknown-linux-gnu": "aecf6c322dc4064dcedf2315d443a69e099fc52e617711306fa1269cb180aa68",
+    "llvm-tools-1.49.0-x86_64-unknown-linux-musl": "c53b602056f48c38624942c1f6b6cc1a5a542cb56249a3a90c67355da531bd40",
+    "llvm-tools-1.50.0-aarch64-apple-darwin": "4a03b09dc15644fd5a10ac8aa1dc3ec32bc832f0c27bce4fa6128f18ac22a90d",
+    "llvm-tools-1.50.0-aarch64-unknown-linux-gnu": "25256ce02516667890abf82fa4d49a86f16dcea448d63c9a03782c0a3bbe05c1",
+    "llvm-tools-1.50.0-aarch64-unknown-linux-musl": "cfe980fe89486c78a5c88701e8ce6a9c7914030c703d2b3ee841b84c1ccdf31d",
+    "llvm-tools-1.50.0-x86_64-apple-darwin": "d8b018570e8ff163c4ab37a36ce16128b39c2ea55efd1be3caf14bdd85d03394",
+    "llvm-tools-1.50.0-x86_64-pc-windows-msvc": "728f7a656f27eb6361847d245d23b56b7109c7ef5f47117044e83aaf49fcc536",
+    "llvm-tools-1.50.0-x86_64-unknown-freebsd": "4300261729751c6a7353cc4a4bb3d6c448fcc24e90a82e3d626af037fb6aae4c",
+    "llvm-tools-1.50.0-x86_64-unknown-linux-gnu": "86871fb83afba38ba818286c20bc863798b64a7a403ecb0454535bf1a09df482",
+    "llvm-tools-1.50.0-x86_64-unknown-linux-musl": "98f2266ffbcf1d94e2d6961341ef6488ef3f49a81ae4c857c4b817cc9528535b",
+    "llvm-tools-1.51.0-aarch64-apple-darwin": "1a12dd5bd2c354a89737640ac105600f59fc038809ad4611b29eb0d225bd783d",
+    "llvm-tools-1.51.0-aarch64-unknown-linux-gnu": "5295ca2bbaa8d37942ed95f801107900d40f326f543edf4c80a1c2adf48fb077",
+    "llvm-tools-1.51.0-aarch64-unknown-linux-musl": "2dfbe582660bac4a674186a475a5a3d118aa2369dc70eb9d8e93cd13a66cb50f",
+    "llvm-tools-1.51.0-x86_64-apple-darwin": "1c52b39cae8fb17e64c311eb9ab66e475b6ae8190b35c6513344271b7e172d3e",
+    "llvm-tools-1.51.0-x86_64-pc-windows-msvc": "cb2dd2a21deb3228ce3e7e2495b95d34b5c985eae39126170d823ff1b585a240",
+    "llvm-tools-1.51.0-x86_64-unknown-freebsd": "a2f698841b8f860bf5a841f5f53dea8fd9df53c19c3b6d15cbe43a327696ffea",
+    "llvm-tools-1.51.0-x86_64-unknown-linux-gnu": "398a587c088ac159322bf47d1736409ab88d3a45eb9e09bfb7bacbbf20627e49",
+    "llvm-tools-1.51.0-x86_64-unknown-linux-musl": "0b7a9e46dd64fdef3ce22bd5a69d4599a17c120ae645fadadd7371b03f2dacd8",
+    "llvm-tools-1.52.0-aarch64-apple-darwin": "f3b3a9dbef7a00fe26a38d143585d3ca79b85c6dc6326c31ea3de178715d2456",
+    "llvm-tools-1.52.0-aarch64-unknown-linux-gnu": "9550b39d38ffdb32231fbc3893a362dc325448aa05b4197845d7fb799ec556e6",
+    "llvm-tools-1.52.0-aarch64-unknown-linux-musl": "7dd8f795ec2d9f2eeb67e98e08341ab46416bf8f307a8395d6c7d289f4f6a641",
+    "llvm-tools-1.52.0-x86_64-apple-darwin": "0160eca2c73cd54b47c226c6f0f6ae4841300bbf8384426bbfb03a814b30cf84",
+    "llvm-tools-1.52.0-x86_64-pc-windows-msvc": "baf0810ece6694ed431010a24d9c81386f150567b48f79fac952e411927d3058",
+    "llvm-tools-1.52.0-x86_64-unknown-freebsd": "cdb385cc036a9f354639050384584e64e6464a8ccfd422db17b3a2df82b88eb8",
+    "llvm-tools-1.52.0-x86_64-unknown-linux-gnu": "bd5056c50b92e48787d164d4d93db332c3f02e2913b3d86edabddfa248c3aeba",
+    "llvm-tools-1.52.0-x86_64-unknown-linux-musl": "2f5905d5b3198311d2b335ad59d6e14bde9e5eae201df5d723b8b07de37740eb",
+    "llvm-tools-1.52.1-aarch64-apple-darwin": "749d77f5877395081ccbdde25183a4934fa9f771191f1994ef67ab6b845b380f",
+    "llvm-tools-1.52.1-aarch64-unknown-linux-gnu": "94fad9186731f9428ec8a73165294810d63583a04798377298d1569ddf373503",
+    "llvm-tools-1.52.1-aarch64-unknown-linux-musl": "afd4fd18b981bda0a351bf5fff8f6cf76be877aa8840e5e5b159aaffa6979f69",
+    "llvm-tools-1.52.1-x86_64-apple-darwin": "ef5e0713fee477262bff9a8cb2212bd775050ea768a5ba50ceb33e13b58ede17",
+    "llvm-tools-1.52.1-x86_64-pc-windows-msvc": "6823c114ae05ebf515401e44d1ca6fb8d108cbaa495ace60c5fdbd7e81f2b32f",
+    "llvm-tools-1.52.1-x86_64-unknown-freebsd": "470789210cd51acab85662ea5d80f3275d0766f98f59399b6aa3741bde86e773",
+    "llvm-tools-1.52.1-x86_64-unknown-linux-gnu": "db70724d4010273644c4e0ef4739299940b47e307f3dbee094050703147b60f8",
+    "llvm-tools-1.52.1-x86_64-unknown-linux-musl": "ad0755ed04d3e17d11e99aab793a5752e6ef0943a92822874277a13f5b91373f",
+    "llvm-tools-1.53.0-aarch64-apple-darwin": "cd700c4ae2c6fe2a568f477a9db7d7c9cd1079456cd777aa04954fbb3bc64e37",
+    "llvm-tools-1.53.0-aarch64-unknown-linux-gnu": "916307648b13cd403e5d89e26dc0057a3d6517033b04199b905af7b216ff191b",
+    "llvm-tools-1.53.0-aarch64-unknown-linux-musl": "f19e5396e69a12c854294c61c2ba647e8d06a67750b4bc741c1ec8b44e27ad76",
+    "llvm-tools-1.53.0-x86_64-apple-darwin": "5a693b933e6755fc42983912c0a9197107b61c5ded051526aa0eed60cbb038cf",
+    "llvm-tools-1.53.0-x86_64-pc-windows-msvc": "8d2800c3460935386c0ea368460d0b4cadb152403d3125b9616a1b4fa856cfc4",
+    "llvm-tools-1.53.0-x86_64-unknown-freebsd": "221f677502c4d648e5578cf75224fb017dc4df486bbb15408100f6dc63fb72e9",
+    "llvm-tools-1.53.0-x86_64-unknown-linux-gnu": "4aa6e3c9ef91efc082a6741013fc7886dc669b1532c0c3b23f922e4307200800",
+    "llvm-tools-1.53.0-x86_64-unknown-linux-musl": "b5054bcd14e5a5361f29fe5efa970ab8340c75feebc3c6b7719ee4cf1cf1027a",
+    "llvm-tools-1.54.0-aarch64-apple-darwin": "61bb98566e77f998f59c2399c5db3b488cd88e4a7bcce74061bbbb6de5c85c62",
+    "llvm-tools-1.54.0-aarch64-unknown-linux-gnu": "95dd016daee815e6511ed09becba913e5aa1fc6b9ef42bc27d1a509f660dec99",
+    "llvm-tools-1.54.0-aarch64-unknown-linux-musl": "8cac2dd2d1ef582c77b37b6810122426369028351a66a355c38ff72efb8f6ec4",
+    "llvm-tools-1.54.0-x86_64-apple-darwin": "a287d049bf7beb3a3cddf62974e0450d21bb09da72ab453222dffc3f5ef72fef",
+    "llvm-tools-1.54.0-x86_64-pc-windows-msvc": "e1437993d0088f93871e2563c570fb62aec6109087227df7da8779ef226abbc3",
+    "llvm-tools-1.54.0-x86_64-unknown-freebsd": "024fcaabada32629381b5d1ec856d595eacf5cf506c43619d2ab454aeac7da4c",
+    "llvm-tools-1.54.0-x86_64-unknown-linux-gnu": "aa4000bccc5e463c9cc3aecb6b400813a0f122b5f14a747710f23b838b4fbcc8",
+    "llvm-tools-1.54.0-x86_64-unknown-linux-musl": "b0e2a74c6e1fb0c9fa888887996cb168c0d119ee4596736a4785b1200b79021b",
+    "llvm-tools-1.55.0-aarch64-apple-darwin": "00a0a90cd743480a192d3f1c905d57b98986d75c88fc738effcbc50c43b0ab85",
+    "llvm-tools-1.55.0-aarch64-unknown-linux-gnu": "259a183333a4f19eded8a2b6fa4382b7f36a9a23605d0f0a7b59a28d794c77d1",
+    "llvm-tools-1.55.0-aarch64-unknown-linux-musl": "a6a6756bb3091d15b772e57189c4279d17e218193b7d795b307effb88d269ef5",
+    "llvm-tools-1.55.0-x86_64-apple-darwin": "fce7354b071f2da56a100f89846e0c5bb3848f2e85e8583102f1d8b409214a95",
+    "llvm-tools-1.55.0-x86_64-pc-windows-msvc": "03307e359512652648b296cecf1e446befbeaf4a3a73db5cec1e6dfbc03f6376",
+    "llvm-tools-1.55.0-x86_64-unknown-freebsd": "f186caf30fadf738275f4daf077815445b4c3496cc7d3e85fbf53b5f8f57eb21",
+    "llvm-tools-1.55.0-x86_64-unknown-linux-gnu": "ebad576075c4dd039444ca7335ff244d6c0c566a7ee1532ac80d36a2de1217a5",
+    "llvm-tools-1.55.0-x86_64-unknown-linux-musl": "28de296a08d173bf5bad236935ccc547c8eb741fb91900cb10499e80e2472ec5",
+    "llvm-tools-1.56.0-aarch64-apple-darwin": "4ad514255a87b0aba52bf995cb999bc7b34d42419b675fd757664d6682a45210",
+    "llvm-tools-1.56.0-aarch64-unknown-linux-gnu": "9518804888281bd1b0c8d8467d7c3e312342649ce3660248728a8d4faa193564",
+    "llvm-tools-1.56.0-aarch64-unknown-linux-musl": "095acf10efb3a4561758da9f9374488ab73c88a2f78b6d1ee97147ac8f039fe9",
+    "llvm-tools-1.56.0-x86_64-apple-darwin": "e40341be6619513f50bf89d445e3b30696853f3553bbe98fa9aa3527cd7c49cd",
+    "llvm-tools-1.56.0-x86_64-pc-windows-msvc": "838bf630fdaa404f9899a92e58c1b5646f4f4b6d54729e4f1c3aade5585a74f7",
+    "llvm-tools-1.56.0-x86_64-unknown-freebsd": "05225a9aeb481757b470ee604a129bfc7707d85dc487fffcc2585f4124e012d9",
+    "llvm-tools-1.56.0-x86_64-unknown-linux-gnu": "ac54b5c1bae0955945cd779291bc443b3e6d52f217ce1078a3505bae1c0e2ff2",
+    "llvm-tools-1.56.0-x86_64-unknown-linux-musl": "9512db06f3090028b0ba26aeea21c3a80e6676177c92cfa1e60d13acd6871f0e",
+    "llvm-tools-1.56.1-aarch64-apple-darwin": "8feb4429f37d2c59a97a657052a8518492ea3e0c43b37af1e44407bb04d5fd8c",
+    "llvm-tools-1.56.1-aarch64-unknown-linux-gnu": "3c831ad4ee247ae29a5acecba1609d70b02777ba8181d40a945d2efedebc8126",
+    "llvm-tools-1.56.1-aarch64-unknown-linux-musl": "bf62fb69c222c41c83cb5e647dbce207519724c92de8e05015e7fe62396ad33e",
+    "llvm-tools-1.56.1-x86_64-apple-darwin": "75dc2fb8105e33e3f86753eb2f97615f62bc3433591c31f63fa7c4c12b643321",
+    "llvm-tools-1.56.1-x86_64-pc-windows-msvc": "34ff6e95ce6397b954691f5ae59068bf33f8ecf71fe8aa8b1ac2db6eaff81720",
+    "llvm-tools-1.56.1-x86_64-unknown-freebsd": "b8d281cdae768bdd87409e69c916612e1fed29334d861fd07b0d44dd8b6d086d",
+    "llvm-tools-1.56.1-x86_64-unknown-linux-gnu": "61e322fc405540fae66790a0317d3fe4bb500da20879ef53c14eb32e93590ee6",
+    "llvm-tools-1.56.1-x86_64-unknown-linux-musl": "880e2eae8998ee390c3cd325b1806adb627c7491a252af99fc87f43380e1f11a",
+    "llvm-tools-1.57.0-aarch64-apple-darwin": "712e59804a2dc7c0f0a91680c3ccd7463bfe75784e508b4a47b7eebff258867f",
+    "llvm-tools-1.57.0-aarch64-unknown-linux-gnu": "340fcbf4555cc56232225284b500679f33601689bde3122cd54af7648c9d0ce1",
+    "llvm-tools-1.57.0-aarch64-unknown-linux-musl": "5de4f546695db024c74ad8c4ffbd03f549ce6476bdad8d40bd8fce59e4c3d4ce",
+    "llvm-tools-1.57.0-x86_64-apple-darwin": "4ee2065bf9ca04894c6ea700f5fe13f222843dc34b1bf92fc94f37c03e47f6b3",
+    "llvm-tools-1.57.0-x86_64-pc-windows-msvc": "dd042fd62e75ff14c1638b9a63072eac42530d29deca2c0277964091f974d3b7",
+    "llvm-tools-1.57.0-x86_64-unknown-freebsd": "0d23df22a31816f5545b5af083dde75a74060889b42ebc8231795bd478f803ce",
+    "llvm-tools-1.57.0-x86_64-unknown-linux-gnu": "bb2f45e0efe77886da2b8b9d3519b6a2929d1654258158d847996867d5b4ab40",
+    "llvm-tools-1.57.0-x86_64-unknown-linux-musl": "7c53a882379938b319c859f41d1f5569b66f1b4f03e745dec2bb3dc8eb11f2b4",
+    "llvm-tools-1.58.0-aarch64-apple-darwin": "55b8ac5d42e3910d7f77f2022a964ec54e4c8082cc6624070d8664c4449b5161",
+    "llvm-tools-1.58.0-aarch64-unknown-linux-gnu": "765d797cc11d746616d71015a52e564220e4e10b8f10efa2fd5fb74ba308ce30",
+    "llvm-tools-1.58.0-aarch64-unknown-linux-musl": "e4b221ea279f698eab0bfebfd2dabca8e2b02c0423c48fb5d0ef281920771b99",
+    "llvm-tools-1.58.0-x86_64-apple-darwin": "7e3f807c85d8b6ff00747d20e88c115bb56a52ac1964593b5ff6bff84bf05647",
+    "llvm-tools-1.58.0-x86_64-pc-windows-msvc": "11aa6d93678766ea8a4625146de43290418f3b9076a69bb183b12613fafc7e5a",
+    "llvm-tools-1.58.0-x86_64-unknown-freebsd": "5950fe6c5a9c27ce0e85d07fd54cfa0ae0687a797e4cc957e91d2deb07451ad1",
+    "llvm-tools-1.58.0-x86_64-unknown-linux-gnu": "26cee659335a999d1c9dd47ac2bd2a8c94c2d42f7cda27b96b419f0c0c785bc7",
+    "llvm-tools-1.58.0-x86_64-unknown-linux-musl": "b20c27a6cfef891f4ac9bfcd06c38dd17f9f4021a7876599092da84c318b8b6b",
+    "llvm-tools-1.58.1-aarch64-apple-darwin": "c43a9166c2cbcc1858afe2de696ee3e6233316603e9f5963bedaaf200a531d29",
+    "llvm-tools-1.58.1-aarch64-unknown-linux-gnu": "bec9207417c9bafa311119565e2a38f36d3aca5f642b8f0e19eb6fa0898fca5c",
+    "llvm-tools-1.58.1-aarch64-unknown-linux-musl": "0faff43fbfc9806355861b906fa0a32dca786843874fcaa7cf911f3899fe9313",
+    "llvm-tools-1.58.1-x86_64-apple-darwin": "0810cbbe2c590ed03128075aaccc77fffb16ceb41bb92490dca2c018117040da",
+    "llvm-tools-1.58.1-x86_64-pc-windows-msvc": "8c5887ebb551ba392cbe915474b4c2494c4b36ece102683240cf4150c5dc1718",
+    "llvm-tools-1.58.1-x86_64-unknown-freebsd": "b33b2ffa80bb8e3f116b15532acafe56bfb799973ccd97fbe35cb5c8eaeeb8bb",
+    "llvm-tools-1.58.1-x86_64-unknown-linux-gnu": "3d003e6b2a38a6364667ce033ba3fe8029320acbb5b34f9bb103001ffcfef044",
+    "llvm-tools-1.58.1-x86_64-unknown-linux-musl": "a3206ec957f0e8728ad79203f700e4a7d64acccf8b83d11209ac5e459eadab2d",
+    "llvm-tools-1.59.0-aarch64-apple-darwin": "474ba73365de82fa00940887d945931dde56efeb28789c036ab62b90c2e528d1",
+    "llvm-tools-1.59.0-aarch64-unknown-linux-gnu": "e3bc96a602e8cb7768f279c020a3830417e767095dc784b1549510de42c37f5b",
+    "llvm-tools-1.59.0-aarch64-unknown-linux-musl": "5b28d1c6a73b99346dc9f29b4fb0b475814d8bcc3fd9661a2b53bedf606f1bc3",
+    "llvm-tools-1.59.0-x86_64-apple-darwin": "988593882b294423fbd88895b88887da8b47bf28946ae78263b0169a2b2b4597",
+    "llvm-tools-1.59.0-x86_64-pc-windows-msvc": "45f393a71799392ff73cfb17ee071b7304b304c8375db6cdd86f3025b4ba56b0",
+    "llvm-tools-1.59.0-x86_64-unknown-freebsd": "dbb0a7ad6c0e7a87e55a8e3fad05c1ed9ee5944e41e841267d0dfbb748060135",
+    "llvm-tools-1.59.0-x86_64-unknown-linux-gnu": "3bea89788f101b7ea1aca5dad94c3d2bd5f5133999ba78cea878ecad00c8c602",
+    "llvm-tools-1.59.0-x86_64-unknown-linux-musl": "db090aa8093efe163f54e1b211846b9061f835ba21e55cca2e37a5af7ad40e80",
+    "rust-1.26.0-aarch64-unknown-linux-gnu": "e12dc84bdb569cdb382268a5fe6ae6a8e2e53810cb890ec3a7133c20ba8451ac",
+    "rust-1.26.0-x86_64-apple-darwin": "38708803c3096b8f101d1919ee2d7e723b0adf1bc1bb986b060973b57d8c7c28",
+    "rust-1.26.0-x86_64-pc-windows-msvc": "20631bf942242d4be82363030839851bf18a2199b74a661bdc334f830e9e1d5a",
+    "rust-1.26.0-x86_64-unknown-freebsd": "a03cbe097670042c90d18654fbc852c9d473261d61c03d0f745bbaee759780ed",
+    "rust-1.26.0-x86_64-unknown-linux-gnu": "13691d7782577fc9f110924b26603ade1990de0b691a3ce2dc324b4a72a64a68",
+    "rust-1.26.1-aarch64-unknown-linux-gnu": "d4a369053c2dfd5f457de6853557dab563944579fa4bb55bc919bacf259bff6d",
+    "rust-1.26.1-x86_64-apple-darwin": "ebf898b9fa7e2aafc53682a41f18af5ca6660ebe82dd78f28cd9799fe4dc189a",
+    "rust-1.26.1-x86_64-pc-windows-msvc": "56c2398de358094606afba419c1e1a9e499cbe6f894315e99cfebda9f765c52f",
+    "rust-1.26.1-x86_64-unknown-freebsd": "910128f60c680e175ae93722272f491c6835f27652f9f3fe415dc0d9c482e204",
+    "rust-1.26.1-x86_64-unknown-linux-gnu": "b7e964bace1286696d511c287b945f3ece476ba77a231f0c31f1867dfa5080e0",
+    "rust-1.26.2-aarch64-unknown-linux-gnu": "3dfad0dc9c795f7ee54c2099c9b7edf06b942adbbf02e9ed9e5d4b5e3f1f3759",
+    "rust-1.26.2-x86_64-apple-darwin": "f193705d4c0572a358670dbacbf0ffadcd04b3989728b442f4680fa1e065fa72",
+    "rust-1.26.2-x86_64-pc-windows-msvc": "c4195cc0541db7cb08d503cc38917f6f40f53826001e86d613a48bd7387ac6a0",
+    "rust-1.26.2-x86_64-unknown-freebsd": "0ad985cf36b3946f086fd3c3c6eb97b0c94b24285147a04da22c00d4d522727a",
+    "rust-1.26.2-x86_64-unknown-linux-gnu": "d2b4fb0c544874a73c463993bde122f031c34897bb1eeb653d2ba2b336db83e6",
+    "rust-1.27.0-aarch64-unknown-linux-gnu": "e74ebc33dc3fc19e501a677a87b619746efdba2901949a0319176352f556673a",
+    "rust-1.27.0-x86_64-apple-darwin": "a1d48190992e01aac1a181bce490c80cb2c1421724b4ff0e2fb7e224a958ce0f",
+    "rust-1.27.0-x86_64-pc-windows-msvc": "795585a4f49dfcfd719dd6678713d0e84979b265ae9265dcb26b45c67b3a883a",
+    "rust-1.27.0-x86_64-unknown-freebsd": "f0754434f76f261ecdfd7ea3645b251b0188e263c0c7a7466aafac1b034d20ec",
+    "rust-1.27.0-x86_64-unknown-linux-gnu": "235ad78e220b10a2d0267aea1e2c0f19ef5eaaff53ad6ff8b12c1d4370dec9a3",
+    "rust-1.27.1-aarch64-unknown-linux-gnu": "d1146b240e6f628224c3a67e3aae2a57e6c25d544115e5ece9ce91861ec92b3a",
+    "rust-1.27.1-x86_64-apple-darwin": "475be237962d6aef1038a2faada26fda1e0eaea5d71d6950229a027a9c2bfe08",
+    "rust-1.27.1-x86_64-pc-windows-msvc": "24fb59a42277487ab1aaf8ac8b7a988843ae851ffe4a3386d9339e99e42d08d0",
+    "rust-1.27.1-x86_64-unknown-freebsd": "739d38036c9f08c13bc7425cc5cccd3dd37860fa6e9dfc7bcd9081c8d3c5ccdd",
+    "rust-1.27.1-x86_64-unknown-linux-gnu": "435778a837af764da2a7a7fb4d386b7b78516c7dfc732d892858e9a8a539989b",
+    "rust-1.27.2-aarch64-unknown-linux-gnu": "cf84da70269c0e50bb3cc3d248bae1ffcd70ee69dc5a4e3513b54fefc6685fb4",
+    "rust-1.27.2-x86_64-apple-darwin": "30c5cc58759caa4efdf2ea7d8438633139c98bee3408beb29ceb26985f3f5f70",
+    "rust-1.27.2-x86_64-pc-windows-msvc": "be1cccbd4cc00d473cb19fee4402d0ffde3b1e3ca3701926d47590878bc88508",
+    "rust-1.27.2-x86_64-unknown-freebsd": "b114c5eebc120b360d4d3c4360421ff181cc47bb311e161d3af6971b6d3e6244",
+    "rust-1.27.2-x86_64-unknown-linux-gnu": "5028a18e913ef3eb53e8d8119d2cc0594442725e055a9361012f8e26f754f2bf",
+    "rust-1.28.0-aarch64-unknown-linux-gnu": "9b6fbcee73070332c811c0ddff399fa31965bec62ef258656c0c90354f6231c1",
+    "rust-1.28.0-x86_64-apple-darwin": "5d7a70ed4701fe9410041c1eea025c95cad97e5b3d8acc46426f9ac4f9f02393",
+    "rust-1.28.0-x86_64-pc-windows-msvc": "5990e79259967a6a176aa5e4c55c6395f0c9262eed61ea858cfb909bac477542",
+    "rust-1.28.0-x86_64-unknown-freebsd": "cac701973239cbec802780855b172a3cc85ce15602e72873fe966d9d7d807e07",
+    "rust-1.28.0-x86_64-unknown-linux-gnu": "2a1390340db1d24a9498036884e6b2748e9b4b057fc5219694e298bdaa37b810",
+    "rust-1.29.0-aarch64-unknown-linux-gnu": "0ed3be0fd9f847afeb4e587fff61f6769ea61b53719d3ea999326284e8975b36",
+    "rust-1.29.0-x86_64-apple-darwin": "28a0473637585742f6d80ccd8afd88b6b400e65d623c33cb892412759444da93",
+    "rust-1.29.0-x86_64-pc-windows-msvc": "64f8c85540520c82d579d7eac5e2a524b42a6083cc46c7e80181512651a66fef",
+    "rust-1.29.0-x86_64-unknown-freebsd": "3500b1683849cbe526bb79f460147aa387b79a4f9a6a4760e276f73ddbffafd5",
+    "rust-1.29.0-x86_64-unknown-linux-gnu": "09f99986c17b1b6b1bfbc9dd8785e0e4693007c5feb67915395d115c1a3aea9d",
+    "rust-1.29.1-aarch64-unknown-linux-gnu": "2685224f67b2ef951e0e8b48829f786cbfed95e19448ba292ac33af719843dbe",
+    "rust-1.29.1-x86_64-apple-darwin": "07b07fbd6fab2390e19550beb8008745a8626cc5e97b72dc659061c1c3b3d008",
+    "rust-1.29.1-x86_64-pc-windows-msvc": "ec15b45be27b4406122518b2949f6186f0d9d422f23a946ab4de43716cc8e492",
+    "rust-1.29.1-x86_64-unknown-freebsd": "4055a9e9990f83f6c0d4f2040b2704edb8dbdaf82933f8598ab4ee31c541bbb9",
+    "rust-1.29.1-x86_64-unknown-linux-gnu": "b36998aea6d58525f25d89f1813b6bfd4cad6ff467e27bd11e761a20dde43745",
+    "rust-1.29.2-aarch64-unknown-linux-gnu": "e11461015ca7106ef8ebf00859842bf4be518ee170226cb8eedaaa666946509f",
+    "rust-1.29.2-x86_64-apple-darwin": "63f54e3013406b39fcb5b84bcf5e8ce85860d0b97a1e156700e467bf5fb5d5f2",
+    "rust-1.29.2-x86_64-pc-windows-msvc": "7813396fb99021e9a8bccb2fc7e71b1b730d5f3aebbb09ffcc2ecb838a1073b4",
+    "rust-1.29.2-x86_64-unknown-freebsd": "2e209d505c730df6e68575424eec03ed924e12114ad60595602cb2513c6a382a",
+    "rust-1.29.2-x86_64-unknown-linux-gnu": "e9809825c546969a9609ff94b2793c9107d7d9bed67d557ed9969e673137e8d8",
+    "rust-1.30.0-aarch64-unknown-linux-gnu": "9690c7c50eba5a8461184ee4138b4c284bad31ccc4aa1f2ddeec58b253e6363e",
+    "rust-1.30.0-x86_64-apple-darwin": "07008d90932712282bc599f1e9a226e97879c758dc1f935e6e2675e45694cc1b",
+    "rust-1.30.0-x86_64-pc-windows-msvc": "960ca17c0c62ee250647c20b617e75912badb67ca8ade08c3224410a7c320ade",
+    "rust-1.30.0-x86_64-unknown-freebsd": "b4e5d00b318d56edb7ba9182af4210fca9d7f44b64bc1380456ff3c17584af52",
+    "rust-1.30.0-x86_64-unknown-linux-gnu": "f620e3125cc505c842150bd873c0603432b6cee984cdae8b226cf92c8aa1a80f",
+    "rust-1.30.1-aarch64-unknown-linux-gnu": "6d87d81561285abd6c1987e07b60b2d723936f037c4b46eedcc12e8566fd3874",
+    "rust-1.30.1-x86_64-apple-darwin": "3ba1704a7defe3d9a6f0c1f68792c084da83bcba85e936d597bac0c019914b94",
+    "rust-1.30.1-x86_64-pc-windows-msvc": "b0110a5ad461532b2cce59bc04346af739b4660e7241f92dde6442a11a5391c2",
+    "rust-1.30.1-x86_64-unknown-freebsd": "480db9003f8e8c4ad12f2868af2c1489a05b18a8dcc62985c52310a7a15201ce",
+    "rust-1.30.1-x86_64-unknown-linux-gnu": "a01a493ed8946fc1c15f63e74fc53299b26ebf705938b4d04a388a746dfdbf9e",
+    "rust-1.31.0-aarch64-unknown-linux-gnu": "4e68c70aba58004d9e86c2b4463e88466affee51242349a038b456cf6f4be5c9",
+    "rust-1.31.0-x86_64-apple-darwin": "5d4035e3cecb7df13e728bcff125b52b43b126e91f8311c66b143f353362606f",
+    "rust-1.31.0-x86_64-pc-windows-msvc": "9288248f1821ab53557cbc5728ade7d221b1670547b0c0ec35099e0b2993dcf4",
+    "rust-1.31.0-x86_64-unknown-freebsd": "936ca1503ab1f18d9a4a1cc27fbc655f2c532ba819e1109bb03f5c52c5fb4fdd",
+    "rust-1.31.0-x86_64-unknown-linux-gnu": "c8a2016109ffdc12a488660edc5f30c1643729efc15abe311ebb187437e506bf",
+    "rust-1.31.1-aarch64-unknown-linux-gnu": "29a7c6eb536fefd0ca459e48dfaea006aa8bff8a87aa82a9b7d483487033632a",
+    "rust-1.31.1-x86_64-apple-darwin": "8398b1b303bdf0e7605d08b87070a514a4f588797c6fb3593718cb9cec233ad6",
+    "rust-1.31.1-x86_64-pc-windows-msvc": "4d2aa25c9d79dca5aba67b7b1df1c1f0ad40fcfb25a4c1d364fd64dd17a63cf3",
+    "rust-1.31.1-x86_64-unknown-freebsd": "5cbb465a0843b31da217c51c4f9ebbb2508aa2ece41e9b98303101e12571de42",
+    "rust-1.31.1-x86_64-unknown-linux-gnu": "a64685535d0c457f49a8712a096a5c21564cd66fd2f7da739487f028192ebe3c",
+    "rust-1.32.0-aarch64-unknown-linux-gnu": "60def40961728212da4b3a9767d5a2ddb748400e150a5f8a6d5aa0e1b8ba1cee",
+    "rust-1.32.0-x86_64-apple-darwin": "f0dfba507192f9b5c330b5984ba71d57d434475f3d62bd44a39201e36fa76304",
+    "rust-1.32.0-x86_64-pc-windows-msvc": "51b0b64cc843d6e443bf19f89b61addb532ea61e02777c7e80a185a9a263776b",
+    "rust-1.32.0-x86_64-unknown-freebsd": "20d062493d01f1816014fe9dbe883bda06f1828a6ddbfb7ee5e4f1df20eb1c3a",
+    "rust-1.32.0-x86_64-unknown-linux-gnu": "e024698320d76b74daf0e6e71be3681a1e7923122e3ebd03673fcac3ecc23810",
+    "rust-1.33.0-aarch64-unknown-linux-gnu": "a308044e4076b62f637313ea803fa0a8f340b0f1b53136856f2c43afcabe5387",
+    "rust-1.33.0-x86_64-apple-darwin": "864e7c074a0b88e38883c87c169513d072300bb52e1d320a067bd34cf14f66bd",
+    "rust-1.33.0-x86_64-pc-windows-msvc": "b477be7a27799397cf90f09ef5efe21b1af02f48ec9bc1be3306ad298aaf8841",
+    "rust-1.33.0-x86_64-unknown-freebsd": "31ab015c1807a7c231ee74b4fb367f3fa43551d6c49cd2f7b63541f1fef0cc72",
+    "rust-1.33.0-x86_64-unknown-linux-gnu": "6623168b9ee9de79deb0d9274c577d741ea92003768660aca184e04fe774393f",
+    "rust-1.34.0-aarch64-unknown-linux-gnu": "370c3a8fb9a69df36d645a95e622fb59ac5b513baecddde706cedaf20defa269",
+    "rust-1.34.0-x86_64-apple-darwin": "e6bea8d865cc7341c17fa3b8f25f7989e6b04f53e9da24878addc524f3a32664",
+    "rust-1.34.0-x86_64-pc-windows-msvc": "471325ceb9492239f7bb399cb88df230791966c0f76f01020aa9d2868bafcfb5",
+    "rust-1.34.0-x86_64-unknown-freebsd": "bc9048312bee935ae1e7417e2f6840ea76fe370752915ca605ec7dc5b606dba9",
+    "rust-1.34.0-x86_64-unknown-linux-gnu": "170647ed41b497dc937a6b2556700210bc4be187b1735029ef9ccf52e2cb5ab8",
+    "rust-1.35.0-aarch64-unknown-linux-gnu": "31e6da56e67838fd2874211ae896a433badf67c13a7b68481f1d5f7dedcc5952",
+    "rust-1.35.0-x86_64-apple-darwin": "ac14b1c7dc330dcb53d8641d74ebf9b32aa8b03b9d650bcb9258030d8b10dbd6",
+    "rust-1.35.0-x86_64-pc-windows-msvc": "4f8935cea6b68c447b5fcb5974e0df3fefc77d15ab4f7d535779f06c3e4adc84",
+    "rust-1.35.0-x86_64-unknown-freebsd": "a6a3c7983a880d8e9bf475735b725c47de68831abc22da980e44a3aca5c5bd89",
+    "rust-1.35.0-x86_64-unknown-linux-gnu": "cf600e2273644d8629ed57559c70ca8db4023fd0156346facca9ab3ad3e8f86c",
+    "rust-1.35.0-x86_64-unknown-linux-musl": "3704219a4d16e4e9df22051877274c7b246d12658b447a85efa0b16037e98093",
+    "rust-1.36.0-aarch64-unknown-linux-gnu": "db78c24d93756f9fe232f081dbc4a46d38f8eec98353a9e78b9b164f9628042d",
+    "rust-1.36.0-x86_64-apple-darwin": "91f151ec7e24f5b0645948d439fc25172ec4012f0584dd16c3fb1acb709aa325",
+    "rust-1.36.0-x86_64-pc-windows-msvc": "c7c9f7f996d195f464b84eaf0b6a068b41d1480e088b12e5134f85a5a144bd30",
+    "rust-1.36.0-x86_64-unknown-freebsd": "eeeb1e9d0d7823c55f00f434789696e7249f465ba5966a5ab479040e3912c0e7",
+    "rust-1.36.0-x86_64-unknown-linux-gnu": "15e592ec52f14a0586dcebc87a957e472c4544e07359314f6354e2b8bd284c55",
+    "rust-1.36.0-x86_64-unknown-linux-musl": "74931a19a4854642cd1593a3bdcf8a832ab5b134a3cfacea9003f9ea387ca88d",
+    "rust-1.37.0-aarch64-unknown-linux-gnu": "263ef98fa3a6b2911b56f89c06615cdebf6ef676eb9b2493ad1539602f79b6ba",
+    "rust-1.37.0-x86_64-apple-darwin": "b2310c97ffb964f253c4088c8d29865f876a49da2a45305493af5b5c7a3ca73d",
+    "rust-1.37.0-x86_64-pc-windows-msvc": "4e42652e7bf7ef13b7fdf8c64d0adf4e18c6a765e482e4c62a4dded36d4d08e1",
+    "rust-1.37.0-x86_64-unknown-freebsd": "58a794fa9da9c14cefda55e7d4d13276517265a05a49f3a048033aee8870388f",
+    "rust-1.37.0-x86_64-unknown-linux-gnu": "cb573229bfd32928177c3835fdeb62d52da64806b844bc1095c6225b0665a1cb",
+    "rust-1.37.0-x86_64-unknown-linux-musl": "d97da4f1c1f89142b6885b006f8686c4035d25e95cfb988f961ce844e5b80dbf",
+    "rust-1.38.0-aarch64-unknown-linux-gnu": "06afd6d525326cea95c3aa658aaa8542eab26f44235565bb16913ac9d12b7bda",
+    "rust-1.38.0-x86_64-apple-darwin": "bd301b78ddcd5d4553962b115e1dca5436dd3755ed323f86f4485769286a8a5a",
+    "rust-1.38.0-x86_64-pc-windows-msvc": "99e2e22084a7c6a114f5353800677e1f7eb4b8cecf1b8841e21ac9579fe8da8c",
+    "rust-1.38.0-x86_64-unknown-freebsd": "a765b1f01a387b15b576b67c77e02609a6d9a6769584742f66f0cac1944c0f7f",
+    "rust-1.38.0-x86_64-unknown-linux-gnu": "adda26b3f0609dbfbdc2019da4a20101879b9db2134fae322a4e863a069ec221",
+    "rust-1.38.0-x86_64-unknown-linux-musl": "14f064fbd34b332866d96db12329ddd6d40525d69d7b8532d3d5387da1217e79",
+    "rust-1.39.0-aarch64-unknown-linux-gnu": "e27dc8112fe577012bd88f30e7c92dffd8c796478ce386c49465c03b6db8209f",
+    "rust-1.39.0-x86_64-apple-darwin": "3736d49c5e9592844e1a5d5452883aeaf8f1e25d671c1bc8f01e81c1766603b5",
+    "rust-1.39.0-x86_64-pc-windows-msvc": "3c96b221af3343c04bf81e621a0b97a2452ae1803ecc2841a162690d8ebfe46f",
+    "rust-1.39.0-x86_64-unknown-freebsd": "9cb25742e727bab0da5feb957ef61f7ffc836b4d5d0e6cabfdf28fb68caf5fdd",
+    "rust-1.39.0-x86_64-unknown-linux-gnu": "b10a73e5ba90034fe51f0f02cb78f297ed3880deb7d3738aa09dc5a4d9704a25",
+    "rust-1.39.0-x86_64-unknown-linux-musl": "f6610742ad223cdd9420707454e4814baf14ab79d73dc033ef190eed28e05cbc",
+    "rust-1.40.0-aarch64-unknown-linux-gnu": "639271f59766d291ebdade6050e7d05d61cb5c822a3ef9a1e2ab185fed68d729",
+    "rust-1.40.0-x86_64-apple-darwin": "749ca5e0b94550369cc998416b8854c13157f5d11d35e9b3276064b6766bcb83",
+    "rust-1.40.0-x86_64-pc-windows-msvc": "64d98af9b9114a3aaea096ba74c43cad75a2502fb682e941b4701f5d2a2b9272",
+    "rust-1.40.0-x86_64-unknown-freebsd": "d1a58e9f743f4a55513f74e41c90ab7b291413ce46336c138762fd9aa6605b32",
+    "rust-1.40.0-x86_64-unknown-linux-gnu": "fc91f8b4bd18314e83a617f2389189fc7959146b7177b773370d62592d4b07d0",
+    "rust-1.40.0-x86_64-unknown-linux-musl": "4fbc6a60c31d89d922cb8c3630a92d7d959a8ec8fa48b51bed9eb67eb0d30b33",
+    "rust-1.41.0-aarch64-unknown-linux-gnu": "79ddfb5e2563d0ee09a567fbbe121a2aed3c3bc61255b2787f2dd42183a10f27",
+    "rust-1.41.0-x86_64-apple-darwin": "b6504003ab70b11f278e0243a43ba9d6bf75e8ad6819b4058a2b6e3991cc8d7a",
+    "rust-1.41.0-x86_64-pc-windows-msvc": "4c43a64e83c28bfb788782b01d95034ecc59bf9846006aa1deb6986c139b9f9d",
+    "rust-1.41.0-x86_64-unknown-freebsd": "ae1093a1e476f5c7b1c1f59f986d64b5f82a76b865c9823bcc3d5061bb93ff9f",
+    "rust-1.41.0-x86_64-unknown-linux-gnu": "343ba8ef7397eab7b3bb2382e5e4cb08835a87bff5c8074382c0b6930a41948b",
+    "rust-1.41.0-x86_64-unknown-linux-musl": "ff7345dde2f5bc295ed8ae50f0eee54b8dd697e712f86095a3378bb4dcfeea70",
+    "rust-1.42.0-aarch64-unknown-linux-gnu": "fdd39f856a062af265012861949ff6654e2b7103be034d046bec84ebe46e8d2d",
+    "rust-1.42.0-x86_64-apple-darwin": "db1055c46e0d54b99da05e88c71fea21b3897e74a4f5ff9390e934f3f050c0a8",
+    "rust-1.42.0-x86_64-pc-windows-msvc": "4a3131ff6d2b04d120069e0ba494a6418db1c691fc8e4627cf1aaf2ffbaf5ad9",
+    "rust-1.42.0-x86_64-unknown-freebsd": "230bcf17e4383fba85d3c87fe25d17737459fe561a5f4668fe70dcac2da4e17c",
+    "rust-1.42.0-x86_64-unknown-linux-gnu": "7d1e07ad9c8a33d8d039def7c0a131c5917aa3ea0af3d0cc399c6faf7b789052",
+    "rust-1.42.0-x86_64-unknown-linux-musl": "1c6bcdf5dfb51c52e7afd33fddd799a0814cd80b443137a8e9eec5563de6849d",
+    "rust-1.43.0-aarch64-unknown-linux-gnu": "e5fa55f333c10cdae43d147438a80ffb435d6c7b9681cd2e2f0857c024556856",
+    "rust-1.43.0-x86_64-apple-darwin": "504e8efb2cbb36f5a3db7bb36f339a1e5216082c910ad19039c370505cfbde99",
+    "rust-1.43.0-x86_64-pc-windows-msvc": "78dea49969addb3ef7a3a3816482534828a5140c866a828be69ccfeb44972a3b",
+    "rust-1.43.0-x86_64-unknown-freebsd": "2555aa83d1559af19054befdaea3ae560374376f9973aa3dad2c41fcd2eb84d4",
+    "rust-1.43.0-x86_64-unknown-linux-gnu": "069f34fa5cef92551724c83c36360df1ac66fe3942bc1d0e4d341ce79611a029",
+    "rust-1.43.0-x86_64-unknown-linux-musl": "dcb022649bc1998d8e103f42cb0847afc57fcd303bc9fdfde057b2b53436605a",
+    "rust-1.44.0-aarch64-unknown-linux-gnu": "bcc916003cb9c7ff44f5f9af348020b422dbc5bd4fe49bdbda2de6ce0a1bb745",
+    "rust-1.44.0-x86_64-apple-darwin": "f20388b80b2b0a8b122d89058f785a2cf3b14e93bcac53471d60fdb4106ffa35",
+    "rust-1.44.0-x86_64-pc-windows-msvc": "127cf6569c4958e362f06f850eec6cba0ad69474ab15fef2dee740aee45a3169",
+    "rust-1.44.0-x86_64-unknown-freebsd": "e2ad3224790d2283d7ef66d5e1f08cec688f1c29cf53326c9a6c28fb4914b6a1",
+    "rust-1.44.0-x86_64-unknown-linux-gnu": "eaa34271b4ac4d2c281831117d4d335eed0b37fe7a34477d9855a6f1d930a624",
+    "rust-1.44.0-x86_64-unknown-linux-musl": "dabcba42caeba91874cf10640f70fb580bdab136ce56211ac341f10d311f6ebc",
+    "rust-1.45.0-aarch64-unknown-linux-gnu": "b727be0ecdee5fb88775b784758a09ab696293048a80288999b8a6f78b160212",
+    "rust-1.45.0-x86_64-apple-darwin": "8e91f99ffbf5ae86d659d3515315a8e92ef44210102672c1536a9902cc182401",
+    "rust-1.45.0-x86_64-pc-windows-msvc": "7d1118568b83fd1da5312de95ca6f30d4f21dae57073c00a216437e4c02733cc",
+    "rust-1.45.0-x86_64-unknown-freebsd": "3d09db6a127558cfdb4fc44106e7d478bb8f6cc6148d536b90d30610181fc656",
+    "rust-1.45.0-x86_64-unknown-linux-gnu": "c34ed8722759fd60c94dbc9069833da5b3b873dcd19afaa9b34c1ce2c2cfa229",
+    "rust-1.45.0-x86_64-unknown-linux-musl": "ca5c4670f511ff225d097b5602d4a2ce984b4cd02c6aedc3be1279570c6475cb",
+    "rust-1.46.0-aarch64-unknown-linux-gnu": "f0c6d630f3dedb3db69d69ed9f833aa6b472363096f5164f1068c7001ca42aeb",
+    "rust-1.46.0-x86_64-apple-darwin": "82d61582a3772932432a99789c3b3bd4abe6baca339e355048ca9efb9ea5b4db",
+    "rust-1.46.0-x86_64-pc-windows-msvc": "3545eb66ed7c6222ca4eb9e990d4bef63edbac9b580387bf7035501ee35d453f",
+    "rust-1.46.0-x86_64-unknown-freebsd": "30d8b05073b23f0621ed00276208589dcd7669776b752a67c66c9c928ebbe258",
+    "rust-1.46.0-x86_64-unknown-linux-gnu": "e3b98bc3440fe92817881933f9564389eccb396f5f431f33d48b979fa2fbdcf5",
+    "rust-1.46.0-x86_64-unknown-linux-musl": "57aa5ca25bbd3da4eea6fc411b0fe7e1dbc683230a3f58ec84b9f70c5606909b",
+    "rust-1.47.0-aarch64-unknown-linux-gnu": "753c905e89a714ab9bce6fe1397b721f29c0760c32f09d2f328af3d39919c8e6",
+    "rust-1.47.0-x86_64-apple-darwin": "84e5be6c5c78734deba911dcf80316be1e4c7da2c59413124d039ad96620612f",
+    "rust-1.47.0-x86_64-pc-windows-msvc": "c9f93f8c821090e1c96384bef564e9c9d86bd13ef8d1116b3f17e124f07f55cc",
+    "rust-1.47.0-x86_64-unknown-freebsd": "650af0288d099c9debef7258a27caf15dd8aaf033ee1a099b4c5216c95ecfeaa",
+    "rust-1.47.0-x86_64-unknown-linux-gnu": "d0e11e1756a072e8e246b05d54593402813d047d12e44df281fbabda91035d96",
+    "rust-1.47.0-x86_64-unknown-linux-musl": "63be7601a9ecc552e3cb7a7b8f781bc122f756e8c61e4da4b76f995af039e53f",
+    "rust-1.48.0-aarch64-unknown-linux-gnu": "c4769418d8d89f432e4a3a21ad60f99629e4b13bbfc29aef7d9d51c4e8ee8a8a",
+    "rust-1.48.0-aarch64-unknown-linux-musl": "ac4de580a28e45a9773b389b296d13bfeeb08263cb1f8343859577a54940dae9",
+    "rust-1.48.0-x86_64-apple-darwin": "20e727cad10f43e3abcedb2a80979ae26923038e0e8a855e8a783da255054113",
+    "rust-1.48.0-x86_64-pc-windows-msvc": "0fdf41bb9b45e923000205b08329e15124f01b9b32986d73cd36625f3c7d883b",
+    "rust-1.48.0-x86_64-unknown-freebsd": "21e24489ffaabe517e5e87572707784d5b471646164109b248957a2d32e7a8b9",
+    "rust-1.48.0-x86_64-unknown-linux-gnu": "950420a35b2dd9091f1b93a9ccd5abc026ca7112e667f246b1deb79204e2038b",
+    "rust-1.48.0-x86_64-unknown-linux-musl": "4ed9627f57b4e0b9807fc5e7513d9731f4791668b7f875b9e44e65e21072c56f",
+    "rust-1.49.0-aarch64-apple-darwin": "ce7d689e6f73dd9c07b672ba23dabe5159fa8c194dce71b4f3f95baeaf564082",
+    "rust-1.49.0-aarch64-unknown-linux-gnu": "b551bd482041307fa3373a687d6d6a2c4c0931c2e0a68b8b75dc80bc5cf5f002",
+    "rust-1.49.0-aarch64-unknown-linux-musl": "0a43d96a508c720520328112d609916d062f866a5c35f1db8f906284035d6d98",
+    "rust-1.49.0-x86_64-apple-darwin": "fe3e248bc4b0ee0a2595693687ad845c8a8bda824a56c9321520bcca02433716",
+    "rust-1.49.0-x86_64-pc-windows-msvc": "5340831dcf98344de4a6888b50237f82568a97a46d9814f1400720dde0c7b6e5",
+    "rust-1.49.0-x86_64-unknown-freebsd": "dced98577e834f511cae8e58290539ad6b8dd40ae512e90d1371f650961bd930",
+    "rust-1.49.0-x86_64-unknown-linux-gnu": "8b14446df82f3707d69cf58fed92f18e0bff91621c62baf89288ef70e3e92981",
+    "rust-1.49.0-x86_64-unknown-linux-musl": "f92a5a4adcfac4206a223d089a364a8375d1b6f112f3f2efa3f6d53d08a61904",
+    "rust-1.50.0-aarch64-apple-darwin": "1ed91a867e7b86cc4bc84c0838240f1c25acd007100ec9f7a14c4873e4b56561",
+    "rust-1.50.0-aarch64-unknown-linux-gnu": "1db7a4fbddc68cd29eb9bca9fa7d0d2d9e3d59ede7ddaad66222fb4336a6bacf",
+    "rust-1.50.0-aarch64-unknown-linux-musl": "adcc6c76a8967bacb6687b565d3cf739e35fde066b03edb745b05b52fa8b5b36",
+    "rust-1.50.0-x86_64-apple-darwin": "1bf5a7ecf6468ce1bf9fe49c8083b3f648b40c16fbfb7539d106fe28eb0e792e",
+    "rust-1.50.0-x86_64-pc-windows-msvc": "e8857c30b43b7d92371f824303d18e90e67e1053497366ad3496fa7ba0e0de6e",
+    "rust-1.50.0-x86_64-unknown-freebsd": "83f9d093ab7f0f5abac15e0fcea6f22daef217a2b6240342b71ae52f99a7f31d",
+    "rust-1.50.0-x86_64-unknown-linux-gnu": "fa889b53918980aea2dea42bfae4e858dcb2104c6fdca6e4fe359f3a49767701",
+    "rust-1.50.0-x86_64-unknown-linux-musl": "867cbfb35f5dc9b43e230132ea9e7bfa98d471a9248e41b08ced2266e5ccd00f",
+    "rust-1.51.0-aarch64-apple-darwin": "95d0410bbd20b05f8b7d5adf70e8737873995bc86611a90e643d7081ca35147f",
+    "rust-1.51.0-aarch64-unknown-linux-gnu": "fd31c78fffad52c03cac5a7c1ee5db3f34b2a77d7bc862707c0f71e209180a84",
+    "rust-1.51.0-aarch64-unknown-linux-musl": "06cdaa1117dcdd392ede938b655b9bc45cf2a76bd42870ca223189e6eb29d435",
+    "rust-1.51.0-x86_64-apple-darwin": "765212098a415996b767d1e372ce266caf94027402b269fec33291fffc085ca4",
+    "rust-1.51.0-x86_64-pc-windows-msvc": "aa0a7c78c68a2f23b72a95976f74aa5b883feb20812698b8ee0b07a86314ebc5",
+    "rust-1.51.0-x86_64-unknown-freebsd": "d764ab80889460caca86cda7b7ca2ced80544bb477634adc8cade0e27f4f663b",
+    "rust-1.51.0-x86_64-unknown-linux-gnu": "9e125977aa13f012a68fdc6663629c685745091ae244f0587dd55ea4e3a3e42f",
+    "rust-1.51.0-x86_64-unknown-linux-musl": "cb65c3a19ba0e09a94ccfd8551e648efaa1db52b0db19ae475d35a46f8750871",
+    "rust-1.52.0-aarch64-apple-darwin": "3aa15896dd85d1746a23af1b9764b55edb3659823ec20f306a5f30271c6bac5d",
+    "rust-1.52.0-aarch64-unknown-linux-gnu": "d37152f9da1074cfa84407ff183ce0dfb298f2e474d5b0ae3a3065d44c442770",
+    "rust-1.52.0-aarch64-unknown-linux-musl": "af73b6e9a99151f60569411fedcf5dfefb89bbec61548a2b4a8157874da77816",
+    "rust-1.52.0-x86_64-apple-darwin": "18906ea9ef6d7afc493f0c4403ece9fb466b0971db8d37d837864676ef9b077b",
+    "rust-1.52.0-x86_64-pc-windows-msvc": "53ad54808b1320aff5cc772f007a7f6570afceeb9c5b70b4b09fec9363610d59",
+    "rust-1.52.0-x86_64-unknown-freebsd": "f0610d69f18f861b72240cd6d42dae43adf932eadc24619a48e5a9363f719cdb",
+    "rust-1.52.0-x86_64-unknown-linux-gnu": "c082b5eea81206ff207407b41a10348282362dd972e93c86b054952b66ca0e2b",
+    "rust-1.52.0-x86_64-unknown-linux-musl": "56e36a3e626dca9eb65a07109ecd65e0454d9882124a6cda66ad21e78b82f627",
+    "rust-1.52.1-aarch64-apple-darwin": "217e9723f828c5359467d69b363a342d702bdcbbcc4107be907e6bc4531f4912",
+    "rust-1.52.1-aarch64-unknown-linux-gnu": "17d9aa7bb73b819ef70d81013498727b7218533ee6cf3bd802c4eac29137fbcb",
+    "rust-1.52.1-aarch64-unknown-linux-musl": "f2bae2b32f05a90eec041352d9329deb3e907f5560b9fda525788df3b8008b6b",
+    "rust-1.52.1-x86_64-apple-darwin": "cfa73228ea54e2c94f75d1b142ea41444c463f4ee8562a3eca1b11b2fe8af95a",
+    "rust-1.52.1-x86_64-pc-windows-msvc": "c03fb39f39519abd65ce792cc3d2c038b6c4179089d21f9e26933b93cde402d9",
+    "rust-1.52.1-x86_64-unknown-freebsd": "74e8386d2a9b1363ac8f5b0637e4c38a305d4706babda5222801c5ec9d5a2e6d",
+    "rust-1.52.1-x86_64-unknown-linux-gnu": "617ae06e212cb65bc4abbf52b158b0328b9f1a6c2f822c27c95b274d6fbc0627",
+    "rust-1.52.1-x86_64-unknown-linux-musl": "c3eae6e78ee29e03416897f89b54448b2a03d063f07a78cde41757ad2e02c2f0",
+    "rust-1.53.0-aarch64-apple-darwin": "c519da905514c05240a8fe39e459de2c4ef5943535e3655502e8fb756070aee1",
+    "rust-1.53.0-aarch64-unknown-linux-gnu": "cba81d5c3d16deee04098ea18af8636bc7415315a44c9e44734fd669aa778040",
+    "rust-1.53.0-aarch64-unknown-linux-musl": "a0065a6313bf370f2844af6f3b47fe292360e9cca3da31b5f6cb32db311ba686",
+    "rust-1.53.0-x86_64-apple-darwin": "940a4488f907b871f9fb1be309086509e4a48efb19303f8b5fe115c6f12abf43",
+    "rust-1.53.0-x86_64-pc-windows-msvc": "4690fb3ff390eef30eca4b3b9193a74e0e00ef18f2d89b7981753aaa9b36d787",
+    "rust-1.53.0-x86_64-unknown-freebsd": "f87eee8fabffc5800d5285ce2116e9c0f39340fed4a3c77eeb9fbbf7659b25c4",
+    "rust-1.53.0-x86_64-unknown-linux-gnu": "5e9e556d2ccce27aa8f01a528f1348bf8cdd34496c35ec2abf131660b9792fed",
+    "rust-1.53.0-x86_64-unknown-linux-musl": "908b6163b62660f289bcd1eda1a0eb6d849b4b29da12546d24a033e5718e93ff",
+    "rust-1.54.0-aarch64-apple-darwin": "801b3b15b992b0321261de8b8ea2728e9a74822c6cb99bf978b34e217c7825ba",
+    "rust-1.54.0-aarch64-unknown-linux-gnu": "33a50c5366a57aaab43c1c19e4a49ab7d8ffcd99a72925c315fb1f9389139e6f",
+    "rust-1.54.0-aarch64-unknown-linux-musl": "49d94116a357ea13f5a3231de2472f59210028c3cf81f158b8a367c3155ac544",
+    "rust-1.54.0-x86_64-apple-darwin": "5eb27a4f5f7a4699bc70cf1848e340ddd74e151488bfcb26853fd584958e3d33",
+    "rust-1.54.0-x86_64-pc-windows-msvc": "1c01182f8d9ef1295eacf58e5b7ba2e3183d768b91f7f650a7421808779068a0",
+    "rust-1.54.0-x86_64-unknown-freebsd": "026a40470b9fddfbb4abff3546e620eceaa2812ffc13e180bbb9360c01501a16",
+    "rust-1.54.0-x86_64-unknown-linux-gnu": "350354495b1d4b6dd2ec7cf96aa9bc61d031951cf667a31e8cf401dc508639e6",
+    "rust-1.54.0-x86_64-unknown-linux-musl": "3571db0018fcd32f3b579a32b2301826dbd1cce44b373aed8e8a31c2a6f52fe8",
+    "rust-1.55.0-aarch64-apple-darwin": "70c71d30d0de76912fcd88d503a6cb4323cfe6250c1a255be7e0d4e644b3d40a",
+    "rust-1.55.0-aarch64-unknown-linux-gnu": "eebdb2e659ed14884a49f0457d44e5e8c9f89fca3414533752c6dbb96232c156",
+    "rust-1.55.0-aarch64-unknown-linux-musl": "2ce36a7d34f1f2aa43b4cbc0b437d96eefb45743828bf9ae699ff581ae257f28",
+    "rust-1.55.0-x86_64-apple-darwin": "2e345ac7724c192c9487a2c6bd4f6c52c884d791981510288830d27d9a0bf2f3",
+    "rust-1.55.0-x86_64-pc-windows-msvc": "c7f21e819d883306c3a06115b4d46a92c7310aed655a2f19b40c457a6f06ba62",
+    "rust-1.55.0-x86_64-unknown-freebsd": "7ddb8ec4d431f64dd6428df93d46f726516970b0ca83c71c3efbfe34a42d3113",
+    "rust-1.55.0-x86_64-unknown-linux-gnu": "2080253a2ec36ac8ed6e060d30802d888533124b8d16545cfd4af898b365eaac",
+    "rust-1.55.0-x86_64-unknown-linux-musl": "f24f68587253c4bfbe59d3d10fe4897068d9130538de6b2d02097a25718030c2",
+    "rust-1.56.0-aarch64-apple-darwin": "31b7e9c8b4ac3133b1952d1278077fa45250e26758625f972f9b2f4e2426709d",
+    "rust-1.56.0-aarch64-unknown-linux-gnu": "f3e9a9c8af7d17a2fbe0ce561a7dc42f65c5444025783f1f63cd47960a534a9e",
+    "rust-1.56.0-aarch64-unknown-linux-musl": "a97c8f305c0dd07925a00f90e135152769f1c97442874691ffc865602209066d",
+    "rust-1.56.0-x86_64-apple-darwin": "577faef3f118a4a259e5e61a415b06434081baeceeff7bbf2357456cfc5b8735",
+    "rust-1.56.0-x86_64-pc-windows-msvc": "7ebee9ae583d0723d945fe89244fbc6f51f8723d318a2be9bcbe1e4ffc33606f",
+    "rust-1.56.0-x86_64-unknown-freebsd": "e31a47ecdd223ef7c84fc50d2c51343f8a3e54d419b04e17d143bd81ed587a7f",
+    "rust-1.56.0-x86_64-unknown-linux-gnu": "5189cd56447f9d56fcd7a1966efe5a8efd19843fdfd6bf9a23a9acbc57b5e3f9",
+    "rust-1.56.0-x86_64-unknown-linux-musl": "6ad1c6fa11e3bce86368385d0b0512d723a426fa55bcaeafdab08d03f127275d",
+    "rust-1.56.1-aarch64-apple-darwin": "e71c14c1368048a22e4d1851f301872ac2e6f4c574f04d2a7ae4d64b0e7c7235",
+    "rust-1.56.1-aarch64-unknown-linux-gnu": "69792887357c8dd78c5424f0b4a624578296796d99edf6c30ebe2acc2b939aa3",
+    "rust-1.56.1-aarch64-unknown-linux-musl": "971d13d41657e50e3ac54f17f52b4198c3d8bc25ec489a6a9e6d12c18226dda5",
+    "rust-1.56.1-x86_64-apple-darwin": "8d65ef02a123c23be00101fb204d28b60498b9145dd2ee8edabf0afde6e01e55",
+    "rust-1.56.1-x86_64-pc-windows-msvc": "b39acf48e5d73279ca9485f50e6ec16c16fcef922eb17f2921ce807df11d3e5b",
+    "rust-1.56.1-x86_64-unknown-freebsd": "94e2c8b44af125ca8ba1a1ded7e7b9c5acb27e52acec4ab483d5ed9a8528c5a9",
+    "rust-1.56.1-x86_64-unknown-linux-gnu": "a6be5d045183a0b12dddf0d81633e2a64e63e4c2dfa44eb7593970c1ef93a98f",
+    "rust-1.56.1-x86_64-unknown-linux-musl": "3c09058d104d9a88943fb343af1fb70422f9c4a987e6703666ee8a8051211190",
+    "rust-1.57.0-aarch64-apple-darwin": "7511075e28b715e2d9c7ee74221779f8444681a4bb60ac3a0270a5fdf08bdd5a",
+    "rust-1.57.0-aarch64-unknown-linux-gnu": "d66847f7cf7b548ecb328c400ac4f691ee2aea6ff5cd9286ad8733239569556c",
+    "rust-1.57.0-aarch64-unknown-linux-musl": "91c8e5171e5715261f7f635142a10a9415a4e5ba55374daf76f0b713c8b08132",
+    "rust-1.57.0-x86_64-apple-darwin": "15ceffc4743434c19d08f73fb4edd6642b7fd8162ed7101d3e6ca2c691fcb699",
+    "rust-1.57.0-x86_64-pc-windows-msvc": "566374ae6c9f487726932f4d4ef3c9000147574f30365cfda265cbfd0c4ea5c6",
+    "rust-1.57.0-x86_64-unknown-freebsd": "ebe96fa1f15e8d70c91e81aab7e0c341717b909225029f37d52fbdfa506e3fab",
+    "rust-1.57.0-x86_64-unknown-linux-gnu": "ea0253784b2e5c22659ff148d492a68d2e11da734491714ebc61cc93896efcda",
+    "rust-1.57.0-x86_64-unknown-linux-musl": "56876ebca0e46236208c8bd3c3425dba553abe49639e1040ee8b95bc66a45d33",
+    "rust-1.58.0-aarch64-apple-darwin": "6fb564f03dc09fd0ede8cdc35803b9efdd0ee3b3769c392c63167f863e9512ce",
+    "rust-1.58.0-aarch64-unknown-linux-gnu": "38fafc97700dcb1d205d3db7d86e9eb404577ccc4054333f41ec52d508394043",
+    "rust-1.58.0-aarch64-unknown-linux-musl": "787655adcaf004cc1f6a438881a3964ec20fffa682b46418a2a87b564548d80b",
+    "rust-1.58.0-x86_64-apple-darwin": "1f35e32a70ced5019fef45d1073d8ac25c0c2f91537b2b3592e041542f582b84",
+    "rust-1.58.0-x86_64-pc-windows-msvc": "c15f4ac3ef3a3833b6394f3f102cc7896a82107d68c2f398aab2bfd70fbb096a",
+    "rust-1.58.0-x86_64-unknown-freebsd": "ce69d9e2b7f60d7805d7759f112a9a3d2c608715242041e7fecea033d557bab1",
+    "rust-1.58.0-x86_64-unknown-linux-gnu": "1d7ec4bceb0d31f163540fe7ebebed68ca8853e7982821108770eaec5d66f871",
+    "rust-1.58.0-x86_64-unknown-linux-musl": "d1d04e4c5a3299c1d4b3eac8785f7b77c23d4ed32da3c3f77a1e39d90264b386",
+    "rust-1.58.1-aarch64-apple-darwin": "00b44985bc87e53c53d92622fb10226f09e9f25c79db48a77c0a769a36f83b1e",
+    "rust-1.58.1-aarch64-unknown-linux-gnu": "ce557516593e4526709b0f33c2e1d7c932b3ddf76af94c2417d8d667921ce90c",
+    "rust-1.58.1-aarch64-unknown-linux-musl": "b1533fdeeda483a3633617fd18a79d8fad7821331614b8dc13efd8b22acc30f5",
+    "rust-1.58.1-x86_64-apple-darwin": "d0044680fc132a721481b130a0a4282a444867f423efdb890fe13e447966412f",
+    "rust-1.58.1-x86_64-pc-windows-msvc": "93cebf7a895420b3763dbc808c0772ef814add757eb689abe1da3690e876447f",
+    "rust-1.58.1-x86_64-unknown-freebsd": "124d056c3af35bd9a42c6ef3529c73a6b29b1d927f5498cec499e16ca4defe63",
+    "rust-1.58.1-x86_64-unknown-linux-gnu": "4fac6df9ea49447682c333e57945bebf4f9f45ec7b08849e507a64b2ccd5f8fb",
+    "rust-1.58.1-x86_64-unknown-linux-musl": "7036e34eadc8ce22d16b0625919d9f2244ca49a5441d6599f4822116c181d272",
+    "rust-1.59.0-aarch64-apple-darwin": "5449ae915982967bae97746ce8bea30844f9ab40b4ee4da392b9997e0e7b2926",
+    "rust-1.59.0-aarch64-unknown-linux-gnu": "ab5da30a3de5433e26cbc74c56b9d97b569769fc2e456fc54378adc8baaee4f0",
+    "rust-1.59.0-aarch64-unknown-linux-musl": "a3f8afdf23c98e6d25bf3b4bfcf5e9a4712f4c425f3754500931232d946204a9",
+    "rust-1.59.0-x86_64-apple-darwin": "d82204f536af0c7bfd2ea2213dc46b99911860cfc5517f7321244412ae96f159",
+    "rust-1.59.0-x86_64-pc-windows-msvc": "d781bfed7e3e5dc4959ce39df101fc476a3a70ab75e2fa1bbc3e59281f6e9e00",
+    "rust-1.59.0-x86_64-unknown-freebsd": "83f9c49b6e9025b712fc5d65e49f1b6ad959966534cd39c8dc2ce2c85a6ca484",
+    "rust-1.59.0-x86_64-unknown-linux-gnu": "0c1c2da3fa26372e5178123aa5bb0fdcd4933fbad9bfb268ffbd71807182ecae",
+    "rust-1.59.0-x86_64-unknown-linux-musl": "c0ae76fa4bb0f1c85b86b9f7637db0fddf5084ce4c8f86c4d4acc3c41813201f",
+    "rust-src-1.26.0": "d02fe6fd5c0f330656e9ff0a290ebf23cab7c909f96ce1838247fadc117eb1dd",
+    "rust-src-1.26.1": "19ef8113ae53ec7ea8f6772a5c9ce5a3dfc28b1bddd800841fb5bbec33fa3619",
+    "rust-src-1.26.2": "d63cb7ca67f1bb2101898b7ca33105eeb6d9d9cc3e7ff566b90b0321ec448e73",
+    "rust-src-1.27.0": "9a60d9f0c586a537129a741576370b90d9cce1999b4aa2623d5c1d9c3fdf5a73",
+    "rust-src-1.27.1": "8736577a84bf7263d333996b21ec49697a4a942ab1b5f6d1327241866481cdc0",
+    "rust-src-1.27.2": "03b4b09d855b2c393508f1e5d11c2cba147112a534193e62d6cb54e2b5a631f1",
+    "rust-src-1.28.0": "99ee2a227f27bf0136e7bc53790ef5e02ad9744a56f488b77579403b281b1d63",
+    "rust-src-1.29.0": "6f1a4457d2e75d2b3d3dda1f05e6ff5f37c4c416d25733cb3b008cad99247a42",
+    "rust-src-1.29.1": "89bddeeb0b38ec2715e287a4827179fc975d69bd6d223b05199321e9c0de8313",
+    "rust-src-1.29.2": "47b1ed6d19d5a14f20c1723218fcf073c3f790aceb780ffae9209c1a480f5b81",
+    "rust-src-1.30.0": "27e806396aa5ce2466929e06106a23b456a63f9dee2e9c378da326f1f88e6570",
+    "rust-src-1.30.1": "16dc694d49b22a58e766dfa5812d84000a6197cc6b1f1f7b4e553be8d9427d85",
+    "rust-src-1.31.0": "121909b2428487a31d6bef4ff92f6d63967b225310632fc60570874ba392feb1",
+    "rust-src-1.31.1": "097550782be7f201a44b842b74c6c2ec6851495454ada2d9ee693a8af4cdbc6a",
+    "rust-src-1.32.0": "6ece16e38b969606a5da8def53cae55d0c67d8502261086afbd5e303013ce92b",
+    "rust-src-1.33.0": "48b28b0cd9badcef24f1525b6a225db9018924567d6a998ae891996dc843fb22",
+    "rust-src-1.34.0": "6fe16aae312d3be5e0fec93e52918b7b03e0920e7d6d3e552a4fdd740556c4e9",
+    "rust-src-1.35.0": "7547d1e9a7ed236860e0a1ed7b9e428941fad7ff9bd3888e19db7e7a5fd53e38",
+    "rust-src-1.36.0": "c0099d763779ef095fcd32531a88a2af714670ec0b64f7b27aa027b2f51057b0",
+    "rust-src-1.37.0": "30e7bb28725b86b53b7dfe23ba4f3119889c30e38930f7c2dfdc74b1f62704a5",
+    "rust-src-1.38.0": "082891ceb8547c4a0fbadcd1309fb0219b935f3dc5a38d2b3b77f40a670a0a54",
+    "rust-src-1.39.0": "068186f866703ffeae804a0642588a78a492f03b62c0113e6cdfcb4eeca56df6",
+    "rust-src-1.40.0": "2a9be624ba682f1331cc4d764e161a1b18e007ded34ffcb1494804bc24e0fd62",
+    "rust-src-1.41.0": "6597a1f217c6a9cfcf41e34bba91d8d98b6736ab6a18b54ed2db1ce5634e176a",
+    "rust-src-1.42.0": "56d809eb9efb70e9444be88bd8e3ff54d94ab5fef24b13d5b17a75309190d84e",
+    "rust-src-1.43.0": "7999fad1e60609f76ebe589cab48451e35ecd54d5336bf70dfb0eb57c78e8bb7",
+    "rust-src-1.44.0": "6f748c303431126827fc3f262ba05ece2456e274eafeb9bd0b40bdf27c5f99da",
+    "rust-src-1.45.0": "96590b0a987098da05d38f8e3bb5e049a77c20f03689ffb7144f23136fd488b4",
+    "rust-src-1.46.0": "7478839072096041220c6ca9cc9031028cdf65fa8cb5bcf87178ea1351442bdc",
+    "rust-src-1.47.0": "64b27ba31f8956342e8ace0f949d06524d7013bf73bfbe6f9d18ec19e5a0c793",
+    "rust-src-1.48.0": "e8f15bdfcb5ced76ae40dd9aa6b387d5f9cece82b7a340cdcaa353fbc94f53da",
+    "rust-src-1.49.0": "474a0fd0c1da720eb9fa701c73ced702a7599eb265333a18c1b25feeb9566f8e",
+    "rust-src-1.50.0": "678e140e88656f19a49aa802eb6e1ea117a520c6f3eb0da265a7dc6e0c012a9c",
+    "rust-src-1.51.0": "18904ca04c5bc09fa1a88d32391c611bc60bc3a739551496cad0829e34301563",
+    "rust-src-1.52.0": "861dcbf1faf2faca5b5e3afea5bbcf453cbda4ae00bd34ae67bfc36463f9e227",
+    "rust-src-1.52.1": "34fb417e94aadbace368e934e1f079dd09f2423ccd6cc0cc519cdd55ef3fa8bf",
+    "rust-src-1.53.0": "26b1464bd313ae99de27a162ca96b4fb321e4414448ea8ce8abd715ef8c7ba2b",
+    "rust-src-1.54.0": "56d14ee97c59c543291154ab427cf96a1a82ef5cf32b89f14886dcfc01f5310b",
+    "rust-src-1.55.0": "3be79e301246b413e9e1cc4b5b4f53bcbc964482005381a899ab6c597bef7996",
+    "rust-src-1.56.0": "00c2225d0e1d430b1632373c46448b1b69839032b8384684091bb9cce19b2ce6",
+    "rust-src-1.56.1": "be4757c283f94a37cf38b9897f5513ebe3e2f4ef15f013630cdb845987324503",
+    "rust-src-1.57.0": "cc1fa22e939b14a6952deb7547fcfafa6670e727f942fb4ef77075d8e58e45a6",
+    "rust-src-1.58.0": "c91bb6df4ebbfea42a1c3940e38bc1c2c4768efbdada8205b12f6d9d383ee219",
+    "rust-src-1.58.1": "e7bb7325e5e71411aabfbd251acfd131d1ad6d9aee2b65d04b081702915cfe4f",
+    "rust-src-1.59.0": "127658a5237cce6dd43ce9d9113fc104ea6902cc8c850272fba07d92140fab12",
+    "rust-std-1.26.0-aarch64-unknown-linux-gnu": "a583ddc2d4b5f9516bf136f781268ae0e813295d1d145fab4b46a4220f448923",
+    "rust-std-1.26.0-aarch64-unknown-linux-musl": "6a112ecd4cdefee2688bf69fdceb785a4d08cea33ba32296539abe3cb7f5eae1",
+    "rust-std-1.26.0-wasm32-unknown-unknown": "0f8bb8bdb523cd05acd11006d47b14d7589e64fe25a43d1aec5df692988b400f",
+    "rust-std-1.26.0-x86_64-apple-darwin": "cb5a0114e9e383aa93267868482db84f791124ee4faafdaed08ec6782d000fc2",
+    "rust-std-1.26.0-x86_64-pc-windows-msvc": "88ae8697a84cfddc72429fb0880e6d8663d99ab98a69d27c06d21b4e668b13d9",
+    "rust-std-1.26.0-x86_64-unknown-freebsd": "38cd138eba2ccaff59513d154fec580b6663ca6ef38cd620c348364aa1e11a40",
+    "rust-std-1.26.0-x86_64-unknown-linux-gnu": "e27cb5c21541a500c8df919e15c8d3b002456ebbe573122e7b058cf5b4c3c13a",
+    "rust-std-1.26.0-x86_64-unknown-linux-musl": "943886ce013589b6dd9c9392c807881631cab4a8e04acc83e3a047134a9294f5",
+    "rust-std-1.26.1-aarch64-unknown-linux-gnu": "34077f14d1e8c9ce96a9c72e95599326187bd460b88f877794a8c19f9e1b56b4",
+    "rust-std-1.26.1-aarch64-unknown-linux-musl": "d4435fa89ff7575d8d70114a5841bf70d699294db707512d6f4f4d0a073b237d",
+    "rust-std-1.26.1-wasm32-unknown-unknown": "98af245301a921042997a433a618f58ae27b52340ad71c5502ecde7f29db79f9",
+    "rust-std-1.26.1-x86_64-apple-darwin": "d43e06674e645e120af6716e6d0db5771fa8818b5a48fbee9791360086cdec4a",
+    "rust-std-1.26.1-x86_64-pc-windows-msvc": "5223b7dde5b96d278072b4541fdffb7d33c64950af643eba385928763aca32bf",
+    "rust-std-1.26.1-x86_64-unknown-freebsd": "1d63cc1f6dc6dfa2644619cd8c264c3d1be0fe5c44c5454e8ea04bd7beb036fb",
+    "rust-std-1.26.1-x86_64-unknown-linux-gnu": "cc7cec9a121a97e8e23c350305a0e4cd4e3b475fd5a36fa6335a585d3c511f0d",
+    "rust-std-1.26.1-x86_64-unknown-linux-musl": "9d6a4191ad8ddfae10a05882cd0e867ecc2b64d26da2f38fbdcbdcbcf94139cf",
+    "rust-std-1.26.2-aarch64-unknown-linux-gnu": "6f629b8c3ef8aa4a6c9439a5c1d8719905853f321a1080bb9f8a8356a1b06364",
+    "rust-std-1.26.2-aarch64-unknown-linux-musl": "d70817352ebe34fab475ef3cd79ccbd56cf20e3b9ae0b34a285dd1c966bf2bde",
+    "rust-std-1.26.2-wasm32-unknown-unknown": "260e3267451c8098ac069376e2f4320e129ccec79602086a77f0798499cb5b3b",
+    "rust-std-1.26.2-x86_64-apple-darwin": "712a79cd10b96c7119980e535a36595e03c69a360f1541f690c09de858d92723",
+    "rust-std-1.26.2-x86_64-pc-windows-msvc": "41036c06e00ba038c5ec3940608370e93c6b9a731019d0349841fa78bc8ea125",
+    "rust-std-1.26.2-x86_64-unknown-freebsd": "f54b58bf941d794ee10ab7ee9e1c94a70012073b0ee633ec2be585b1be2e31de",
+    "rust-std-1.26.2-x86_64-unknown-linux-gnu": "91634f05bf2d0a20e627aed08a8450673acecb963869273221de17130540fb26",
+    "rust-std-1.26.2-x86_64-unknown-linux-musl": "5ba536ccc53bf550d7ae3f032cc743b2f13c1ac92e3be45f0843762ed8aa4ca0",
+    "rust-std-1.27.0-aarch64-unknown-linux-gnu": "a32ff8d2ab75a229b73076182978e8b97ac1c5447b9446b1d253685ef31652ec",
+    "rust-std-1.27.0-aarch64-unknown-linux-musl": "e64ee59e3c113483714c563a567532eba46c96ff7e7f3982e88fecf03d0c1cae",
+    "rust-std-1.27.0-wasm32-unknown-unknown": "aa1afca259ecbee3cf65368e8f9d5e9a0d8ea86be30edf4ecfedecc1db110380",
+    "rust-std-1.27.0-x86_64-apple-darwin": "15ee6418f9b564618e9c81a6dcd7706a2f8ae5ca24fd1b6d7527c97563a47e57",
+    "rust-std-1.27.0-x86_64-pc-windows-msvc": "77c9102d192ed2dda7128dea4e60992d1135c50b85f0ef8e989f0fda3ed3b73c",
+    "rust-std-1.27.0-x86_64-unknown-freebsd": "6e307cc3798b50b37beb9ff43e88b12fb565ddaf051925fffa35bfbeb091d660",
+    "rust-std-1.27.0-x86_64-unknown-linux-gnu": "b8cf36922315ca792929d515327c74b873358a64be4929b2ecfbe23af21e8043",
+    "rust-std-1.27.0-x86_64-unknown-linux-musl": "166b5286de202feebfbbfea18f2cc06b0a945dd7687985d6a14b3c811b18b202",
+    "rust-std-1.27.1-aarch64-unknown-linux-gnu": "00a553c4b5869db1acc4f5fb1f6f954893db507ae01ed754bb8654f8916588e9",
+    "rust-std-1.27.1-aarch64-unknown-linux-musl": "aabf69e0ed8a0a45a1dd7c52bf532cff37ab00c1aa5cd1555ca57e4fee9dc64d",
+    "rust-std-1.27.1-wasm32-unknown-unknown": "e16cfda8a8eb29c81d34ea3ca7b4c0815b46ddb85814cbf68320f2666ef44d78",
+    "rust-std-1.27.1-x86_64-apple-darwin": "a521599355e564984e43a63042b1de93dd7cf96730930501f86611dd766384e8",
+    "rust-std-1.27.1-x86_64-pc-windows-msvc": "4745f31711f18e06859946b932909a26d4593552c6631c5710e72d3da26f06ab",
+    "rust-std-1.27.1-x86_64-unknown-freebsd": "12902b61a4897ade258217f045dfac3fe83d49dd52d1e2250bd94c3a10642b08",
+    "rust-std-1.27.1-x86_64-unknown-linux-gnu": "9a1830b522117d68eeec703b50692093352212e035a46baceea666bb37739c2d",
+    "rust-std-1.27.1-x86_64-unknown-linux-musl": "c387d462fc07d4bace1355cfca70b68ff263432614cbe7c66d53ac25e1a47161",
+    "rust-std-1.27.2-aarch64-unknown-linux-gnu": "39bafd1db4f1e881cdbd8d81b757bfef1cad6c06f6aa4514f8b693d997764e2a",
+    "rust-std-1.27.2-aarch64-unknown-linux-musl": "5e8e6d5368ece8c822991c8b4437e83d0537f253cb70b39d627d17f012813122",
+    "rust-std-1.27.2-wasm32-unknown-unknown": "59ad2323afe090c43e41dce482a4abed1473a7997db5db2ee236d49eac208b70",
+    "rust-std-1.27.2-x86_64-apple-darwin": "eed3688d9f551066593b34f07e4d28846caa99624c2168387993acc6bddd003d",
+    "rust-std-1.27.2-x86_64-pc-windows-msvc": "f5dbee42f3fde455d79e759a4854da78a650df3bcf27f194da78670feb11e10a",
+    "rust-std-1.27.2-x86_64-unknown-freebsd": "6051f8bacbfbd2c3dceeddab8c66274bed7ef260cf346d367c53495cd1567572",
+    "rust-std-1.27.2-x86_64-unknown-linux-gnu": "68984f2233853d3e9c7c56edd72a91b5822157f28fdb42023fb311af68f842dd",
+    "rust-std-1.27.2-x86_64-unknown-linux-musl": "2ef23cad3779c8ee7abf7cbe7d93b0faa1ffd87e1ef5a378aa9ce566cd1b7644",
+    "rust-std-1.28.0-aarch64-unknown-linux-gnu": "9ba698f68c5643f53934e1085af40c79c6d1b3bfa01ca6dcdffdc5eec8f44cc0",
+    "rust-std-1.28.0-aarch64-unknown-linux-musl": "b1acdf055d534f4ce295271fe6101833c65261aeb52ffb619911a4db3de35663",
+    "rust-std-1.28.0-wasm32-unknown-unknown": "33f9b2d3f568859db28ab32ec4dd388390d408f6204ab44886eec04cc08af843",
+    "rust-std-1.28.0-x86_64-apple-darwin": "bd1b5110d35383349aafad904431d55656b13a3c02ed3b2020d2038557735ab9",
+    "rust-std-1.28.0-x86_64-pc-windows-msvc": "876d68628e6e91113117516621ae4773cdbebdaab1e899d3ec83c612683947b8",
+    "rust-std-1.28.0-x86_64-unknown-freebsd": "1fabaf71d21c1cdcddfb564950152ef862b519a175f7ee88d7e22bab31c4733e",
+    "rust-std-1.28.0-x86_64-unknown-linux-gnu": "c5aed4c7ef362b5754526d26acaccdc9300942fd12e5cc67cc56fc89576a9dab",
+    "rust-std-1.28.0-x86_64-unknown-linux-musl": "caea8f24197232c25de0e387567af452e0d57b9103ef8acef167814f9acda08c",
+    "rust-std-1.29.0-aarch64-unknown-linux-gnu": "72c0ab49bbdbf819da5018b620aeed22d34af558f4db9598059cb253fc6adec3",
+    "rust-std-1.29.0-aarch64-unknown-linux-musl": "63f9cef857800feae763ba5356f1aa67b6d2d5c8c13e03378d79014e41eacf17",
+    "rust-std-1.29.0-wasm32-unknown-unknown": "83449101356a3ae4abf8597913602b1c79dd76cc52bca7a6a3a9f4fdabc565d5",
+    "rust-std-1.29.0-x86_64-apple-darwin": "7fca06854f7c63d1d0da7c46c816af5dd23eb8010603b8cf3f07a61b162f02ae",
+    "rust-std-1.29.0-x86_64-pc-windows-msvc": "b05d04c684e070a820a0a3dc1128a24795895aecf25f6ffa0d68150e6209e424",
+    "rust-std-1.29.0-x86_64-unknown-freebsd": "a59a50a60b033c00cf36c3b8039f300b2997245c21f2d02074f9d3157b54b353",
+    "rust-std-1.29.0-x86_64-unknown-linux-gnu": "0bed2fcba596e1af6f56ed3f5d481b89b28a4ac26aea07128c6630c00c6a136b",
+    "rust-std-1.29.0-x86_64-unknown-linux-musl": "f45012af49d05990b0917c465a7986be466d2dcf6fb82100903ba0dc7f63469c",
+    "rust-std-1.29.1-aarch64-unknown-linux-gnu": "cf192e05192f79961b9f9e834e19c8b71654ac98b239408a6815d07ff2a96f19",
+    "rust-std-1.29.1-aarch64-unknown-linux-musl": "fa2f496ee03bff273eb88726e1faa2cbd6156b33ca19acb5e3b2f4c687a5594b",
+    "rust-std-1.29.1-wasm32-unknown-unknown": "48f31123614b5e0799200e0db640ff05c7236d0b6940bedf4043d5d19a2b22df",
+    "rust-std-1.29.1-x86_64-apple-darwin": "9c31fba3bfb816cf6aa8d9d4c3e7f235233035ada95417e130de8487faa507d3",
+    "rust-std-1.29.1-x86_64-pc-windows-msvc": "cb7825c2a1fa46696a429fc7e6afd3f2b396d1467a6e4b5f850ff8dedd73ac1b",
+    "rust-std-1.29.1-x86_64-unknown-freebsd": "aad9e36766284656449dad75cc1c77c7b86da99abfb0ec424689101679aa8a43",
+    "rust-std-1.29.1-x86_64-unknown-linux-gnu": "d05ddae0f05d721de00bf6e40f85f1ccdec902f864b9647e2e1cb08a8202d513",
+    "rust-std-1.29.1-x86_64-unknown-linux-musl": "7ef498c2c817afc7843d301431015931323af1759d325f46b4379bf4dccec331",
+    "rust-std-1.29.2-aarch64-unknown-linux-gnu": "f64b051f0b293ee66d7556231dcd70d143525bf6d0b2afc6fae945bf1ffd8073",
+    "rust-std-1.29.2-aarch64-unknown-linux-musl": "660dcc5252db28a3d46712606a299001fd9a0fe1f27333a88269ab4502315c43",
+    "rust-std-1.29.2-wasm32-unknown-unknown": "e8317f0677a3d4ee3b4e5f2dffdf0cdb930c77da20676a32099fde477b439d5e",
+    "rust-std-1.29.2-x86_64-apple-darwin": "72cd953cb8ea05667f5d58f5c4ba615a564611a86303c0f8f9235e7a53852692",
+    "rust-std-1.29.2-x86_64-pc-windows-msvc": "5f2320e89946208b14a34d96a2bfc652bf1debe2bbf139fda19f7dc3a5f91694",
+    "rust-std-1.29.2-x86_64-unknown-freebsd": "ddde8a33ddd902471c51f273087d90e9f7f184b7f09f5d14cab454c8c4965ec2",
+    "rust-std-1.29.2-x86_64-unknown-linux-gnu": "1fe9a0f354256483a354ee1b51c60bf9f3f48868581f7cb36d0cc51a82400605",
+    "rust-std-1.29.2-x86_64-unknown-linux-musl": "7588af2d23b4e2d342476acfd5fb95dc399777142cf1fb39a6ef0a40d70437bc",
+    "rust-std-1.30.0-aarch64-unknown-linux-gnu": "0166650de5072545c3945416638dec9beec5ae1f3c72069e314b7c50e18b4819",
+    "rust-std-1.30.0-aarch64-unknown-linux-musl": "03ea73844f2963e1716661142a15fc39b8dc026b2654ababe009d31df4e78363",
+    "rust-std-1.30.0-wasm32-unknown-unknown": "e85afbc075e162e9af71795e1dc81fa0d2cf657dd10b74751f1769585321a20f",
+    "rust-std-1.30.0-x86_64-apple-darwin": "33f4a7574c82db1b1bc3f829d0fecf9047bbac073c305500ada4aeaa08272ca9",
+    "rust-std-1.30.0-x86_64-pc-windows-msvc": "7b493d21ac115dc4a1ef85cf0d8e73f688bda065c3abbdf68ff3674c122fb9e4",
+    "rust-std-1.30.0-x86_64-unknown-freebsd": "4040fe677524e2ead69a2fcab4c16acaad3d4c4f1210ae36f400f82463bdfbc7",
+    "rust-std-1.30.0-x86_64-unknown-linux-gnu": "8514eedc0ed99ab75c61be3137c3e57c4115063ddc07aec842f687ebfc7ceda3",
+    "rust-std-1.30.0-x86_64-unknown-linux-musl": "c2fbdb20b81992220002d1c8a4b76b9363711370cc62a42811d2980f9b5c8401",
+    "rust-std-1.30.1-aarch64-unknown-linux-gnu": "64410910d73628a77dfe94dbcd0cd49709b518b5f641fbe4a2476b9af097d47b",
+    "rust-std-1.30.1-aarch64-unknown-linux-musl": "0bdcb6fcf904d0b047d75e0368caf1d29380c62ba5c54254ca8ad777e1e7b5ba",
+    "rust-std-1.30.1-wasm32-unknown-unknown": "0892ab95cdfb0bee3c9981e4a5c69a88c0fc5fb7e0c206638291e91a4c794ee0",
+    "rust-std-1.30.1-x86_64-apple-darwin": "a13d4a748914056f34c2e8691b4ca8ab6d16bb04e6e5fafc22ca594789f4e8b1",
+    "rust-std-1.30.1-x86_64-pc-windows-msvc": "177d887593e29847a1bb7afeb7924c3958248a9ec8604e66671d8036e8fbf9b1",
+    "rust-std-1.30.1-x86_64-unknown-freebsd": "66c91d14d8d3c1523f9b5c52b81e4293ba5378fcf8b3e5d0ed52e96afe6bdd31",
+    "rust-std-1.30.1-x86_64-unknown-linux-gnu": "12c4b164efed44c28096fcd141225ee9bf74e7e3395bc6a60c11c9115a0536c6",
+    "rust-std-1.30.1-x86_64-unknown-linux-musl": "1965d586f74bacb3b7332621c1040aa51efd65393da86da6c5296dafbe57602c",
+    "rust-std-1.31.0-aarch64-unknown-linux-gnu": "02e5b48d8fff293a95b591646e707a8c61399ab6c244508ed842f3d736ded641",
+    "rust-std-1.31.0-aarch64-unknown-linux-musl": "3cedc72a9754219f1684e7037ed10866f0cd756d6ecfaffcd2ef8d57374f85b0",
+    "rust-std-1.31.0-wasm32-unknown-unknown": "ff284b10844cdddca786d85fc3be48796f7286a14350e807fa9912e7748634f0",
+    "rust-std-1.31.0-x86_64-apple-darwin": "7dd4bea941cde8a5ece3286ed43733503c092a8edb50c8c31223a738a526c246",
+    "rust-std-1.31.0-x86_64-pc-windows-msvc": "625e1dbb5996cb9845cb6c779e4a6353faa1e05535471fc00aff6a6f84efeab5",
+    "rust-std-1.31.0-x86_64-unknown-freebsd": "3779f0732ee8fdc1d81663172a72219d59b716e8cc5a6b07bf1d5dd744f74b13",
+    "rust-std-1.31.0-x86_64-unknown-linux-gnu": "fe67a62c7a63acbf2458a36d7689ef41903187a472f0c28850f1fca7ea478da8",
+    "rust-std-1.31.0-x86_64-unknown-linux-musl": "f3bdef5a9e4974296965b36ced9fa3375eb9e3c3d51a305d64b9be47fa2ae55c",
+    "rust-std-1.31.1-aarch64-unknown-linux-gnu": "cc32d23cc2995c4838ab2ed4e709ca9748f13f912e9fbbb7cc78c41dbc4de268",
+    "rust-std-1.31.1-aarch64-unknown-linux-musl": "3d48648a2dad8fb6e7d4eed2d7df14eb20c79e654bc1fe666ab408cebc6e8b72",
+    "rust-std-1.31.1-wasm32-unknown-unknown": "a9b1774a6aed9387b12244d2ac0ea047506ffffee67cd834148f01c66ed24e98",
+    "rust-std-1.31.1-x86_64-apple-darwin": "91c3b12614f9795ef2e0092010f247a38d09c95d4089f75b44fad14679bd1cfb",
+    "rust-std-1.31.1-x86_64-pc-windows-msvc": "e84c961261fe70da68dc56effbb277eadeac51fb5bdd2287a168cbe2ba2b1a2e",
+    "rust-std-1.31.1-x86_64-unknown-freebsd": "89e551403f70eed976ac1dd91c3effc9434ef450da4c347d24a141529f83a101",
+    "rust-std-1.31.1-x86_64-unknown-linux-gnu": "699664b3a64959a2d75e486e19e7cc9934cbcbf2c57a977dd2a2b33cff367da1",
+    "rust-std-1.31.1-x86_64-unknown-linux-musl": "ea622d3bc171a23f704440ea99e96023888425d0c3d90bc6fcc592c17e9f8f54",
+    "rust-std-1.32.0-aarch64-unknown-linux-gnu": "346efe3aef2aff7b71a611bf7661bcec5f9bc4025a599c2866ec5fd330247cb9",
+    "rust-std-1.32.0-aarch64-unknown-linux-musl": "ca67a0ae151de83e077b95dfca459ca2445db461c7e6428c11a32e23e8ea9525",
+    "rust-std-1.32.0-wasm32-unknown-unknown": "5da2824a9404204ce2a72b44961e2dd8854fe2232f65851c1a8ff5c59ef537d5",
+    "rust-std-1.32.0-x86_64-apple-darwin": "b736d035a97f830585360e54e3f8877b68c942211cf0a75e805f34bfb36103a6",
+    "rust-std-1.32.0-x86_64-pc-windows-msvc": "cd9693213bcc2ca0ff1490861d3b52703b65df6f678c3f2ae9ad3f3717e08871",
+    "rust-std-1.32.0-x86_64-unknown-freebsd": "d50f674379791a93764d383153ed6533cea165ede7f233df4e17563bfdab273c",
+    "rust-std-1.32.0-x86_64-unknown-linux-gnu": "9f2705a3ed3217c13fd55569406c52f590030752f57520312e135223ae930caf",
+    "rust-std-1.32.0-x86_64-unknown-linux-musl": "d69a44623be904b48c72adbe0141401c4c1068b4a45502328f9e219e0f833c75",
+    "rust-std-1.33.0-aarch64-unknown-linux-gnu": "26f13cd80c95d484ccffecf517f1e05ce521072a00f1adea43d02b3f9d37f82a",
+    "rust-std-1.33.0-aarch64-unknown-linux-musl": "47c7ed55b77e161c9489ca903be32be80dd0efdf88d55f472bb54cce832629de",
+    "rust-std-1.33.0-wasm32-unknown-unknown": "ea1662a05f89f9fb725cba851f6636316cd80052fed610e4912432e4ee523db1",
+    "rust-std-1.33.0-x86_64-apple-darwin": "94247d4d11c631c9d4256f4b0aedd7fd0379fdb55174405c4c1c0dd0c40097ca",
+    "rust-std-1.33.0-x86_64-pc-windows-msvc": "36d94915b8aa9d3207d31ce77bbb790685cb8263920f0873875ae433fcb8709a",
+    "rust-std-1.33.0-x86_64-unknown-freebsd": "8eec7a21a3368890fdf0b826e7bc1928775724c0a4bd14d86304cc7e48309237",
+    "rust-std-1.33.0-x86_64-unknown-linux-gnu": "661c2ba717ae1502f002b4c6e7aeb8941685c7ea8fe7ac26ed9ede26f615b7af",
+    "rust-std-1.33.0-x86_64-unknown-linux-musl": "c3c0bf38140f7108705bbeeeaebd3dd9e23f556d36796779100c8ecf9142da7f",
+    "rust-std-1.34.0-aarch64-unknown-linux-gnu": "d175e91206aba9e2056a9c5af50f700502e70b2f8eb609854d660ac2f3bf1fff",
+    "rust-std-1.34.0-aarch64-unknown-linux-musl": "2b08cf5b0fdd2cd71e7aece36587fb4869e53faace966eaddb2e2c5fb908eb74",
+    "rust-std-1.34.0-wasm32-unknown-unknown": "4add0e23d048309cd284096c36342a6c2307a293072ced9fceeb6a2a48f3797f",
+    "rust-std-1.34.0-x86_64-apple-darwin": "f5a4fa8e86e1d4483bbe80d0adb08a7f5e466d8173bb5ea596ee698c75d0fd19",
+    "rust-std-1.34.0-x86_64-pc-windows-msvc": "3037d196ac175595de3ddb3c8d26e9795e1765bb083a33da30d2b6afb5b03e17",
+    "rust-std-1.34.0-x86_64-unknown-freebsd": "c012bcf9ee417308fb53b97e58d753f90699bd516bcafd6cc83d6f0a54423f3e",
+    "rust-std-1.34.0-x86_64-unknown-linux-gnu": "6565dbe18ee9fa972058b17744ec1129c4fcbf797443f2e16b999df3870d6281",
+    "rust-std-1.34.0-x86_64-unknown-linux-musl": "57e65e5679e7bc00a5bad52de0375f81f91f2f2c3fb1d25af626e4aa4510d80d",
+    "rust-std-1.35.0-aarch64-unknown-linux-gnu": "eee3c6a5c7ef5bc21b626ce350b0e1b02310e0463b6686683262f3fef400746d",
+    "rust-std-1.35.0-aarch64-unknown-linux-musl": "518ba1fb0c0020856eb06ecf3d4d11b94b2ffb0b5f318aac9e086be9b0be2ccd",
+    "rust-std-1.35.0-wasm32-unknown-unknown": "14f1640b35fe351dccd54fc459dea6b7ea199324a723e6d3efc42d519adca99b",
+    "rust-std-1.35.0-x86_64-apple-darwin": "93a640d065d761b85b0f770dfa865b2f86a671a7fac0d5079e4cdc9e4e031011",
+    "rust-std-1.35.0-x86_64-pc-windows-msvc": "2d9091b4a78d7f86b9db5d086b0eebbc2afad4bf828cfbc4b2cc44af86f52210",
+    "rust-std-1.35.0-x86_64-unknown-freebsd": "22e8a2deb83dac920237f810b612b7ea555b03f5830f413a94d007ec683de519",
+    "rust-std-1.35.0-x86_64-unknown-linux-gnu": "5dfa92661ff1a22680785bd6999b6117ae66841e2bd9e5318eb97002956131e4",
+    "rust-std-1.35.0-x86_64-unknown-linux-musl": "c9ac131020d4a422191f1e55c66ca5b1bf1b768180cbc2e717eefefec049bd37",
+    "rust-std-1.36.0-aarch64-unknown-linux-gnu": "22bfc32b5003c3d5259babb202f3f66be16fa6f3c75c20f429a16d7ef5eb1928",
+    "rust-std-1.36.0-aarch64-unknown-linux-musl": "42778ab5f87d2dbfc6849fcf0c6e0a3760b18e8c89385130da0a1953d5fed147",
+    "rust-std-1.36.0-wasm32-unknown-unknown": "7fc1d9f19f6674f73fb89c24aeb741adc59896da6d7ce2e16317aa1fb084bea4",
+    "rust-std-1.36.0-wasm32-wasi": "382dd29fa294ef53272984b9121e07d2b50cc131c561bb7ab72bdebda3abc031",
+    "rust-std-1.36.0-x86_64-apple-darwin": "7c6806809e010e5fba1780007ecff5c31f0ad2fcac1b414b98ca3baa0fb41b36",
+    "rust-std-1.36.0-x86_64-pc-windows-msvc": "2ef035a156b7f20a06677f3873631833afdf9cf755af3fc9466c02d9725755eb",
+    "rust-std-1.36.0-x86_64-unknown-freebsd": "a2a923cbfa3481af66c22673cac38e7cb70e26333318ad59c27b8b6ac16a84fe",
+    "rust-std-1.36.0-x86_64-unknown-linux-gnu": "f92425592c02d4681a5c5ae43ac3ad7ddcc218da50fc651ddc5c2240843a7f31",
+    "rust-std-1.36.0-x86_64-unknown-linux-musl": "4d36e7b52839cff72481b2b1858417f382be36ffa5f084f72f35c1a9117c94ea",
+    "rust-std-1.37.0-aarch64-unknown-linux-gnu": "60d64dde9178fdb698b44315b182375916116e30f5fe7f0d8278dd62eb15e7b3",
+    "rust-std-1.37.0-aarch64-unknown-linux-musl": "68db64972c1af5d4d0c4b3d62b644d158df149eed4197e1c26e93ae4a81e4860",
+    "rust-std-1.37.0-wasm32-unknown-unknown": "b55f82540aa900d2d1d1f6879c9374a8efc78d9eeb20af181ee30182b7f9688c",
+    "rust-std-1.37.0-wasm32-wasi": "551ee5f9adbf24c637e914148c0f161e9e2175aa7d39e5b486d1dd817fb47dec",
+    "rust-std-1.37.0-x86_64-apple-darwin": "0b3fe2575b55a739f409a9d76d05c4bb32494691bde5043d77ba4d39ac182f20",
+    "rust-std-1.37.0-x86_64-pc-windows-msvc": "e03f363296cd60e93110db517f3804631e49fd91de7c0d77b229e31b1135dff2",
+    "rust-std-1.37.0-x86_64-unknown-freebsd": "8783a667ea9c46f27027d494098c51563faa734c5ddb23c6b9b3eda804eb9742",
+    "rust-std-1.37.0-x86_64-unknown-linux-gnu": "09a531a97a16701eb794ecbeeded5d8f8da33da7f1bd372661ad385e3f31c048",
+    "rust-std-1.37.0-x86_64-unknown-linux-musl": "fa1d98bf18fb49ff58a70d51ff7924e4d1975f7812dc5217ea31652bf8b7bca4",
+    "rust-std-1.38.0-aarch64-unknown-linux-gnu": "0725ae9f55639c648fdaba06129de395ed839a7d1aab6aebfd21f26cbe1ce7ca",
+    "rust-std-1.38.0-aarch64-unknown-linux-musl": "56268f0c7c93a4f3436aa20af75e80e29e7d651c754b076c64f13219f2e6be8a",
+    "rust-std-1.38.0-wasm32-unknown-unknown": "9634130c797e8c1fd1d7bbdfd48a32e85e2dd3512ffb2b51974374308cf581cf",
+    "rust-std-1.38.0-wasm32-wasi": "becb178cecc2d2137e006c24e6988d79390f96dcd65cc2e8b2f475a8fdab4bfc",
+    "rust-std-1.38.0-x86_64-apple-darwin": "b1a986e8676aaed25959e9f6dd7c8c5aa67fb829d0d694edea34d8169658a125",
+    "rust-std-1.38.0-x86_64-pc-windows-msvc": "3f5b3c9a4f9015c9e1e12eed94752129d80448ea53f9d5ec1e332c2ffa2c4807",
+    "rust-std-1.38.0-x86_64-unknown-freebsd": "9f1d88449ef56c31ebc514873ba4d5889fa12697c4c2ea1071f15127f301ac4d",
+    "rust-std-1.38.0-x86_64-unknown-linux-gnu": "cd50ec3384d79aae89ffdacf09715b68b1b5562657e993f26f67b9458e92dfdd",
+    "rust-std-1.38.0-x86_64-unknown-linux-musl": "56b87fdca1f41b634285593cae42fdbd5fe9632ef502336679362b283ed53c22",
+    "rust-std-1.39.0-aarch64-unknown-linux-gnu": "adbecacf6cf0ed19df2496cc648b16192c0bd085d7e6f670edcea4dd28ab37df",
+    "rust-std-1.39.0-aarch64-unknown-linux-musl": "1d4a3640fa6e696180848ac2eb10ccc7904acac58784b27e5fcd8a79b2cdf0fa",
+    "rust-std-1.39.0-wasm32-unknown-unknown": "654905b39eae031282a9db9bfa47504c23aa4bbc7d22b769b9bd2f6ca8b61cee",
+    "rust-std-1.39.0-wasm32-wasi": "e7f008fd1f7c902f5ba7777d8a4346783392bd40813c79381bd7497fbcf19be0",
+    "rust-std-1.39.0-x86_64-apple-darwin": "ebd058b16590e2c1a73f5de59d169c8c11be6014934cb083afc84accdccd40d9",
+    "rust-std-1.39.0-x86_64-pc-windows-msvc": "cc704f4c26d5e215a8d98d0797a766fad959101776db69bb392317becd7472ea",
+    "rust-std-1.39.0-x86_64-unknown-freebsd": "94a71addd6983ae844be1cd403926c947766b72f032a083fd1be73f18cf329d9",
+    "rust-std-1.39.0-x86_64-unknown-linux-gnu": "2ddad802f048acaa5cd48f1105c18c7f4de32dc9569ac4d64bfcbb3d8c155cb7",
+    "rust-std-1.39.0-x86_64-unknown-linux-musl": "9c6b49e161e53c174b4fd46825a96b78854cfbcd0971ce846d4edd33c2b5f275",
+    "rust-std-1.40.0-aarch64-unknown-linux-gnu": "e1a1bc577d51556c53e39d4f11fb4918f0ebf27e166ff63321b2991754706d16",
+    "rust-std-1.40.0-aarch64-unknown-linux-musl": "5a269c83446da52c824b3c2047d66540f524e79901ac09b2ac80900a692849dc",
+    "rust-std-1.40.0-wasm32-unknown-unknown": "e3f68aa04c97fb8f5f595d47f417221afb4b0c49d177a2cde7935e3afdd45947",
+    "rust-std-1.40.0-wasm32-wasi": "814d780d7296cc8a8969536f99e8b591fc68d9290e399f01c59cf86d32303718",
+    "rust-std-1.40.0-x86_64-apple-darwin": "1eff41b353403cc284a09debb00cfd41d663447eabf5ad2d4cf736c8c8db0458",
+    "rust-std-1.40.0-x86_64-pc-windows-msvc": "10685476cf7d68e56564730a7d553bacd924717b9272875219da7b9f5ad6704d",
+    "rust-std-1.40.0-x86_64-unknown-freebsd": "90a41f80e2501ac2b036b7cdf269db19a5204aeec257bd585074508f1a6ba2c9",
+    "rust-std-1.40.0-x86_64-unknown-linux-gnu": "735affaca1370699f9bc3fd7b1320694afd250923d283d88c842b7913a97d083",
+    "rust-std-1.40.0-x86_64-unknown-linux-musl": "1183b1f698716409be6b48c8f98109723b5e9f5f2cab6c20f73d0b281c63aa80",
+    "rust-std-1.41.0-aarch64-unknown-linux-gnu": "59b8dab431af29dcd28c6e92e82a488ebb20dbb5dff93ca14119ba8e2fabd9c8",
+    "rust-std-1.41.0-aarch64-unknown-linux-musl": "775a256864417d93d20ae106b775564051be888a78e77a6a88c67ac86e401059",
+    "rust-std-1.41.0-wasm32-unknown-unknown": "0974d40a9f54bd9dda88c20ffa1778fa90ee77a549a8f30ed13477b55e142a63",
+    "rust-std-1.41.0-wasm32-wasi": "e50c63deae8a8bc81d438f73bc885e5de7fa282784171b53e3eebf8f41d8f7d1",
+    "rust-std-1.41.0-x86_64-apple-darwin": "c917af985d879376d8906e7c81ceacb06e65ea7b229ccf81505f8bd6cf5abf64",
+    "rust-std-1.41.0-x86_64-pc-windows-msvc": "aee5b98f0ac533471dc3d9ffdf6fcb22565c44d80c03c1c4df0c8b714931d1a9",
+    "rust-std-1.41.0-x86_64-unknown-freebsd": "4436e80598592398724daf0efc33b2a6505bebde59c021d3e894d605ae5255dd",
+    "rust-std-1.41.0-x86_64-unknown-linux-gnu": "b563fc979eea8372f5b371e10f0857e79cdffc34b124c7a7b0d89014d1b351b7",
+    "rust-std-1.41.0-x86_64-unknown-linux-musl": "6df5f52b7acb58d2123f2a6596741ae1857921ec747087bbd0b0cdf4cec5e369",
+    "rust-std-1.42.0-aarch64-unknown-linux-gnu": "1343f51fc87049327233cee8941629c3d7dfdc425d359385f93665de3d46711b",
+    "rust-std-1.42.0-aarch64-unknown-linux-musl": "77dd67761c8e2e17aaa837b714ddb9dd4433272b6b2980fa327faf23a6fc5bc1",
+    "rust-std-1.42.0-wasm32-unknown-unknown": "695439ef4099f2a1da7c9932e556b3985f4ede5b27e6ef260d670bfe4bc3894b",
+    "rust-std-1.42.0-wasm32-wasi": "077bb250b6df47f1350ea875645fd388d3e6df69830ab49627fe6f6bea5887ad",
+    "rust-std-1.42.0-x86_64-apple-darwin": "1d61e9ed5d29e1bb4c18e13d551c6d856c73fb8b410053245dc6e0d3b3a0e92c",
+    "rust-std-1.42.0-x86_64-pc-windows-msvc": "192d8e1277280df261bc917d1dcc8225b5fb507f281d05bbcf85f859679e1429",
+    "rust-std-1.42.0-x86_64-unknown-freebsd": "76e0f0f7275e114908b0ce2bf39813eaa580af92cc1fab31496ca37ba9d5703e",
+    "rust-std-1.42.0-x86_64-unknown-linux-gnu": "e6bf5495a8b1cfb849fce2753404b3b7ce7fba0c5d743d940fac3ee4558fda26",
+    "rust-std-1.42.0-x86_64-unknown-linux-musl": "c426957a3f2e3d51ee91b996c2c6b21a10d4ade7fb6b7c64d6e2f7100b6b994a",
+    "rust-std-1.43.0-aarch64-unknown-linux-gnu": "f4b80b12ecf14e97937cd24573e82f306f147db6266dc5a2cb27aaeaf49398a7",
+    "rust-std-1.43.0-aarch64-unknown-linux-musl": "5cc80aa5b5cf6dd40a5252de6c2d2cceebd930b80b02bdda7442f93ed6539a55",
+    "rust-std-1.43.0-wasm32-unknown-unknown": "efe2061e7b9711f51b560c7770ebe372003beb9beddb363f27c3960ee12135cd",
+    "rust-std-1.43.0-wasm32-wasi": "6ece090d05853a54bb7f6e4985840cf01dc4857eda0f375bc8e35846d1d533e9",
+    "rust-std-1.43.0-x86_64-apple-darwin": "c75d37579b9e143ebd98ae2fe42c818fd47e0a2763b2a9bdd7e6b9954509d735",
+    "rust-std-1.43.0-x86_64-pc-windows-msvc": "008ca995f429410248558cbfb0e77ebd062ca709a9e3a7d58d9f81c491395280",
+    "rust-std-1.43.0-x86_64-unknown-freebsd": "3c9b450b826874be5c3f35f7cb923f02d4769b81f763fef21c9c0d3a80532c2c",
+    "rust-std-1.43.0-x86_64-unknown-linux-gnu": "84fd8ddaaa217b82c563d4a32a690da2c399388258a3d2baf180992c21938af5",
+    "rust-std-1.43.0-x86_64-unknown-linux-musl": "496efe781a68c1ad75bb16e72b383fdcb9bf28ce448019dbf1ab4742fd4d4299",
+    "rust-std-1.44.0-aarch64-unknown-linux-gnu": "fafb49cc7264a8621c17e8954ec2e0a78e097395b285edb5c1639c61ffb8142c",
+    "rust-std-1.44.0-aarch64-unknown-linux-musl": "b32ccb5a8bf7c3ba9e7295e2986acad87c0eab9eff98a98f4dd3eaa4c8b74405",
+    "rust-std-1.44.0-wasm32-unknown-unknown": "8e12796a0c2fb083953042218f832bdeb78da1bfaf67b9dfe3d719920084d755",
+    "rust-std-1.44.0-wasm32-wasi": "ac0ffeb48bd4be6dd460c5665fc52bb4da2be15e5ecdefa4bf73c6db7392759a",
+    "rust-std-1.44.0-x86_64-apple-darwin": "af58f742764949765e09bb60bd1c16025a79a1be8152996fd5b3a44e5df90311",
+    "rust-std-1.44.0-x86_64-pc-windows-msvc": "1f52376c9a48ce76b24c7aad7a9817b0b4b2cf11a8581001c8d76285d9593340",
+    "rust-std-1.44.0-x86_64-unknown-freebsd": "a0315d028e72e221291dba257e8212e564574d87362cb07e06dc15950d1e6788",
+    "rust-std-1.44.0-x86_64-unknown-linux-gnu": "3b7a4eede0ca550c256ca6721877de0154c27e71196d8b9a980a480682ead0aa",
+    "rust-std-1.44.0-x86_64-unknown-linux-musl": "220877112bc1dafdaa1760c3d1c5b3529766faaa1e969d1a99d27648d3bf927d",
+    "rust-std-1.45.0-aarch64-unknown-linux-gnu": "816f6cc132db84617bfde6ad47336bfb020552a45bd0a10250c4e420d512d5ad",
+    "rust-std-1.45.0-aarch64-unknown-linux-musl": "c37bb023f496161ef3238f37b44606a93e15af225d70d3083bfd52e7f8fdd36a",
+    "rust-std-1.45.0-wasm32-unknown-unknown": "1b4f40be1d0f18a5a04f9f706fef74db0e299046557a706a4dc31a2b36d8de21",
+    "rust-std-1.45.0-wasm32-wasi": "1ef0e8e09ad39275a188bc88d4969c4d1e150cd728d9ff5955b42d6a643ac10c",
+    "rust-std-1.45.0-x86_64-apple-darwin": "e3ac5a3efc106ea13687aa1231609a5d61b1874f4b3a2f68b0e0ad70c89a2364",
+    "rust-std-1.45.0-x86_64-pc-windows-msvc": "f638c04f6709382ded2e78aebff03ae5e40e074d003786f083e6e3ccc438e0b5",
+    "rust-std-1.45.0-x86_64-unknown-freebsd": "68b28ad5488bfb051589c7079bdfa396aa42c29d463a5622fb5eb9d6ecc4a8e6",
+    "rust-std-1.45.0-x86_64-unknown-linux-gnu": "7ab1dbcdeab16dfea1ed024675e60429db9719f03648e6a09662de72b4ff730f",
+    "rust-std-1.45.0-x86_64-unknown-linux-musl": "f54b23b39308b6049644d0c8ac625724911ab423d09ed43dcbc52489b7636ea7",
+    "rust-std-1.46.0-aarch64-unknown-linux-gnu": "eaa7cfd73e96b6ce03498398f4bd9ded73870fe3c5db980038a4863c37157597",
+    "rust-std-1.46.0-aarch64-unknown-linux-musl": "5ad254082e3af2d301d3dd2c9af90942cb91eecb293f86778d163a75cd6bafd1",
+    "rust-std-1.46.0-wasm32-unknown-unknown": "0ef3344aff8ae3f2065ed8f15daa73514a26f934e160cb6974d43a8231fcc090",
+    "rust-std-1.46.0-wasm32-wasi": "44a37dfe4398e1c120a199b2ebbe86838171c38a29a0f76e10ede00bf1aeb16f",
+    "rust-std-1.46.0-x86_64-apple-darwin": "8c897982bc38c9528b448fe551f089fee7716e692dece98052f4459ccc6e591c",
+    "rust-std-1.46.0-x86_64-pc-windows-msvc": "06d92b12e2f4e6024971e99a7716423d4738c3e379fc82aa54de2a812de268b2",
+    "rust-std-1.46.0-x86_64-unknown-freebsd": "e37c06bbe2bf2501675101787388ab87d510ef80f2e091be3f50fc5d019add1e",
+    "rust-std-1.46.0-x86_64-unknown-linux-gnu": "ac04aef80423f612c0079829b504902de27a6997214eb58ab0765d02f7ec1dbc",
+    "rust-std-1.46.0-x86_64-unknown-linux-musl": "cc28b7807ceeb5a7f162edb933d825ed5f5880a45a2e920e1f1a846bfdc1b1a0",
+    "rust-std-1.47.0-aarch64-unknown-linux-gnu": "0019c302a0a02d8a9e40c3bcdd5a31b9b2704161563d72df3572521989182b0c",
+    "rust-std-1.47.0-aarch64-unknown-linux-musl": "69e27f17038a4eb99fe43781f0ca6432f64802bb24fd08fd4f2b90dc73987396",
+    "rust-std-1.47.0-wasm32-unknown-unknown": "b0d19ceb2b56105ee3407bdecaa779747abb1574990632e53a2aba681e964187",
+    "rust-std-1.47.0-wasm32-wasi": "0eab479faac83b9352af04ba4dea376fdeade3101f5e912f40ee3c93e32d1317",
+    "rust-std-1.47.0-x86_64-apple-darwin": "6b86bcdad5a6eff87a67b6387051d7f10a48e088b8f92d76869d201500b9ce13",
+    "rust-std-1.47.0-x86_64-pc-windows-msvc": "896614728a21128c335f632f2f45217320974f71cb4c7c23184610f0b587b7b5",
+    "rust-std-1.47.0-x86_64-unknown-freebsd": "80f5dee782bd74b41c55a676c624ce2260ab54c834102c90ea54e0c5e7e513c6",
+    "rust-std-1.47.0-x86_64-unknown-linux-gnu": "17ecad27d96b331608e4a96dfa3cad05ccb2ccecb888894ed35054e0d1f5207f",
+    "rust-std-1.47.0-x86_64-unknown-linux-musl": "fe4d2ee953979abd09aedaab25fa2ab646089caa6fd4ea9c78486a819729d777",
+    "rust-std-1.48.0-aarch64-unknown-linux-gnu": "3b0e5c4d03ddb97cd462947c539005427813f5ba91be81888db77e7d4bf36e45",
+    "rust-std-1.48.0-aarch64-unknown-linux-musl": "29be0b241bd14651bf9d470a9766000b424a112a0b4a6160f422b075e4668c4c",
+    "rust-std-1.48.0-wasm32-unknown-unknown": "6f981b353e096b8a54c86e6812c82db3b5fd45335b575396e3bfc29b03ffe959",
+    "rust-std-1.48.0-wasm32-wasi": "ed57645e5fe429ef99018759e1a89e090220a3197f30ea544070610ef73c19aa",
+    "rust-std-1.48.0-x86_64-apple-darwin": "430d0ca7c04b0e1140f39f2274e0072a3ba2373a99a230d14ab16361e19b6129",
+    "rust-std-1.48.0-x86_64-pc-windows-msvc": "a526c6f6c00d6a0cd4b6e3348e6329d204099983672862249593ba932b5ddf28",
+    "rust-std-1.48.0-x86_64-unknown-freebsd": "a5ea4ec9664f38a2464216031eeea01f723b4e0691f7d473d8f7ab663551f979",
+    "rust-std-1.48.0-x86_64-unknown-linux-gnu": "2e7152e5d24cea7e44e6645ebbc0387cbe1c7059b54d95d8ea3afe298ac8b2fc",
+    "rust-std-1.48.0-x86_64-unknown-linux-musl": "1bf2a0cfaa3e0cf8f743a48802c91d641a3289dffa1c44d7dc5365b68c8739c4",
+    "rust-std-1.49.0-aarch64-apple-darwin": "cf3308806fc3b6fe00ce49f1e63b1cb1d1443cc812eff7947257f31f590465d3",
+    "rust-std-1.49.0-aarch64-unknown-linux-gnu": "c58bd4f0738ff662f70e35c19bfa6b8eb12ad54b0fbdce32ee3e50186c04a969",
+    "rust-std-1.49.0-aarch64-unknown-linux-musl": "bc5501347598f48f55ba23011602a8fc1fe156c23c1c7b4d449c84eddd64d4ba",
+    "rust-std-1.49.0-wasm32-unknown-unknown": "803b4bd43c711753e3e73c210b88a30c4cfe6f3955902d76e2a15a70ad191ffd",
+    "rust-std-1.49.0-wasm32-wasi": "0c97a1f8470719b741186cbb89c4be6a61057fa013d815b2b97fc1043e269d22",
+    "rust-std-1.49.0-x86_64-apple-darwin": "c4389a8534b8da3ae3570646d68fea9a25268b17ed138867e31d4517312759af",
+    "rust-std-1.49.0-x86_64-pc-windows-msvc": "bb55ad626b9d304c0e080fc8731c7978a937c98e873a84834925c525acdbb5e3",
+    "rust-std-1.49.0-x86_64-unknown-freebsd": "ba97f1d751d6656d5efba4b0278a6571e6a56a489670f279bd2c647a90f1679c",
+    "rust-std-1.49.0-x86_64-unknown-linux-gnu": "f0d2c2d509c29ea9f7c24bb5a885321030281631e0bde0714e5cf881184d57e2",
+    "rust-std-1.49.0-x86_64-unknown-linux-musl": "07d5ebdb6c391631c168deea21c7f4d538ea93c86c2e5e1968508e90835c14e9",
+    "rust-std-1.50.0-aarch64-apple-darwin": "8a1cda91afd3a732d3737b6f933b0b6065949dd8fbc820245a7e2a97ae9a7711",
+    "rust-std-1.50.0-aarch64-unknown-linux-gnu": "83aeff923faa528e2ff5b582e4c3bdaefeda34078345e48878eba6ef95d41040",
+    "rust-std-1.50.0-aarch64-unknown-linux-musl": "fbfa90f58d9c96f91937666ff2495345f564955442109833189ab7dbb0facd89",
+    "rust-std-1.50.0-wasm32-unknown-unknown": "6b639eb5b07e1fee82e58e4fb74b2f40f5c76b02384d27f9675692a7e9656bf6",
+    "rust-std-1.50.0-wasm32-wasi": "205216840a1c286523342adc5c085819e8a4fc6de55efbfb70dc691a463fd8fb",
+    "rust-std-1.50.0-x86_64-apple-darwin": "a291354e78e8147b22e92c817a0dfee8d3342e07bfafa73a2904a1c99d22c5b8",
+    "rust-std-1.50.0-x86_64-pc-windows-msvc": "48e562e1de58bd45aa0d8a95173e159c588ee76b0164affdc0140c928b1994c1",
+    "rust-std-1.50.0-x86_64-unknown-freebsd": "b9b543a310adef1e8432f7edea63b684369b30dad1c30aa12a57ccdaf8ae0224",
+    "rust-std-1.50.0-x86_64-unknown-linux-gnu": "2aaf284a204d605f6685d2000cf83c25d0e1c789093009801ca16e1c659ae8c6",
+    "rust-std-1.50.0-x86_64-unknown-linux-musl": "f8924ff7378552c2f16faba6aea178c1b098f4cfcb07247c7c58533543980594",
+    "rust-std-1.51.0-aarch64-apple-darwin": "b9ed9468652417b375d24152eed9b87436f1ca0ad0311d8a1a802fdde263bdad",
+    "rust-std-1.51.0-aarch64-unknown-linux-gnu": "a6ed4abe59dfaf2119e2803f67fd8aef757a622ae3ac9a040946af2b02f4c269",
+    "rust-std-1.51.0-aarch64-unknown-linux-musl": "9c0dcae82c10d52d202052fa0fa912cd7a21dd286de01717f70e24dfa20a5b03",
+    "rust-std-1.51.0-wasm32-unknown-unknown": "27f4455f01911c2fa1a58cd2fdb3bf5699bf1521cbd462a457c4a1ccb8650e38",
+    "rust-std-1.51.0-wasm32-wasi": "6e96fef8f132934a37169296e7bd13e64ee73679014b47e7bdc399add9b10007",
+    "rust-std-1.51.0-x86_64-apple-darwin": "2856bc46d3624ae2658897c15388c0c353bea916963a2fc5991c23b920d5678c",
+    "rust-std-1.51.0-x86_64-pc-windows-msvc": "0e9300e21b61ec1adde0b48772a76f1c881015cf1e7885b641dcfa1dd8289e55",
+    "rust-std-1.51.0-x86_64-unknown-freebsd": "4d03de5911c533cd0ac2ab5ea9b9105e853ac0ee0f6aea22b6714a7dbe008f01",
+    "rust-std-1.51.0-x86_64-unknown-linux-gnu": "5e7738090baf6dc12c3ed62fb02cf51f80af2403f6df85feae0ebf157e2d8d35",
+    "rust-std-1.51.0-x86_64-unknown-linux-musl": "8e23cf075b514633226e73786bbcc0907853a2e9cba98ec208ca16ba3847b834",
+    "rust-std-1.52.0-aarch64-apple-darwin": "2bf799c9846c9e6308d777d30f38a54acde53b690bd12324dbba3e3b12c44822",
+    "rust-std-1.52.0-aarch64-unknown-linux-gnu": "f16adbfc562875aad7f6a4c9111519ee27eeca804fa575f8d274bd2dc1efa41a",
+    "rust-std-1.52.0-aarch64-unknown-linux-musl": "54d9f39a8a2ebcdec83b0102eac209439f846248cd6b9919421a51448b757bf0",
+    "rust-std-1.52.0-wasm32-unknown-unknown": "d4b059dd880b7c2418c454f6ff9b87f075f8634364d86ade1f4131083951592d",
+    "rust-std-1.52.0-wasm32-wasi": "37a48c39b8a5c41906b003dd803d5d4679a1321c0dd36c222e74b3384592a2d5",
+    "rust-std-1.52.0-x86_64-apple-darwin": "dfab59a96112512f8b3f6550ea932bdc4f09b0c0659545a938dbc334e96b9515",
+    "rust-std-1.52.0-x86_64-pc-windows-msvc": "28adfe2d59d37f179d82fa0ad9b2d0308607abd6c05de0f17458625d83997930",
+    "rust-std-1.52.0-x86_64-unknown-freebsd": "e721b2acb871722a0c36ae2e9d8d97a2ee8175c9c2e3cb80238c662be401b3e2",
+    "rust-std-1.52.0-x86_64-unknown-linux-gnu": "dcea50e20596a698bf534d37f28cabbe6ca6fa31bee9c4c186b0874d1d67d4ed",
+    "rust-std-1.52.0-x86_64-unknown-linux-musl": "6d9883520f6d3cc540114a0246849234a6f801bdfb0346340426b02f4c677063",
+    "rust-std-1.52.1-aarch64-apple-darwin": "3b8914c1e9a51407690661032b059fb87482e93f10f2160f3b042ecc4cb97c38",
+    "rust-std-1.52.1-aarch64-unknown-linux-gnu": "b87ef86a241626cc86bf98fa0e70483f96d1bb9bbb4da7d9c589ac2094393a8d",
+    "rust-std-1.52.1-aarch64-unknown-linux-musl": "fe8091e71cde5e3a344d204a6627765ab79ccf19321348dbfa27768ac5f2abf9",
+    "rust-std-1.52.1-wasm32-unknown-unknown": "83953390e0d1e99cd6572e825888020f91d095b07eb744539a59891837b6fe9b",
+    "rust-std-1.52.1-wasm32-wasi": "7f90fb6336d679ddcce034201645f254d8b97c6352926f5122e38329fd6e1aa6",
+    "rust-std-1.52.1-x86_64-apple-darwin": "3567ec015a498b8d5c6e8f47aaa3ec469a418ea0e0f163249e825ef24457e38b",
+    "rust-std-1.52.1-x86_64-pc-windows-msvc": "ca95b1ddeae98af71439574fdd9fd9b233ffaea7792c1b654c212a1821d33986",
+    "rust-std-1.52.1-x86_64-unknown-freebsd": "5ac8a9dc61421dc4f39380a5d4380130fa176047eef48b3aba205103363b9774",
+    "rust-std-1.52.1-x86_64-unknown-linux-gnu": "ba9cf6570d509b3e4c4d821db4caf304f2ffacf5377b7ca55dc1ef9788ae5b58",
+    "rust-std-1.52.1-x86_64-unknown-linux-musl": "1f3155180a1a143119fd7b1eae3eeed0a0758ca095fd6533918d87cefeb93fe0",
+    "rust-std-1.53.0-aarch64-apple-darwin": "a6191c9b5adab64832c0e0c0ea24f64b32db07ac5f56faf21239055ce38041ed",
+    "rust-std-1.53.0-aarch64-unknown-linux-gnu": "9e5c09d14fec5609bfd042299900f20a44c52d53c64e76e184faadf67d07590d",
+    "rust-std-1.53.0-aarch64-unknown-linux-musl": "7501cc0787a63e550f9918dc5d23ee9fa9f3f3162088b33213694be2d6e2aa32",
+    "rust-std-1.53.0-wasm32-unknown-unknown": "d9539af508a484d7da6b9683aaeb9b50ca63730a14c90837100d668c2591a697",
+    "rust-std-1.53.0-wasm32-wasi": "e75188931308e2dbd6cf85c802d28bbd175a0696cec241b134c17f2ffdfcf10d",
+    "rust-std-1.53.0-x86_64-apple-darwin": "ef9b2d8b467a29c8d5621ca804dfd6b9eb38ceae6ed86c763ddece0a38714697",
+    "rust-std-1.53.0-x86_64-pc-windows-msvc": "b5dc9771dd9b8c2a9fb10769e64c962cea01cc3e0b0057b78ce8a9ba0477a4d0",
+    "rust-std-1.53.0-x86_64-unknown-freebsd": "238bf461d866b5ef4614609462356304eb0225b0c61668d51a7b1844561df845",
+    "rust-std-1.53.0-x86_64-unknown-linux-gnu": "b3428b9ffd5a8f8f13506eedf2fc865665a53894408f0b64314686e8a08d06b2",
+    "rust-std-1.53.0-x86_64-unknown-linux-musl": "e91abd171f35951f1fc56b10af817c9e83833eec5c3712dae8bc1e5e63cb7100",
+    "rust-std-1.54.0-aarch64-apple-darwin": "469b832c7d33c1edfefe705a2ad27172f6906a73b56be789fcc30629792f75b4",
+    "rust-std-1.54.0-aarch64-unknown-linux-gnu": "2d90cd90734a2d057b2a4eeee36a72d96569fb5fff0ac1e22eeb5fab93e66848",
+    "rust-std-1.54.0-aarch64-unknown-linux-musl": "4c689f32444afa8faef2f7eb896b59f76827e9950f795988d626c9e4552e3d4b",
+    "rust-std-1.54.0-wasm32-unknown-unknown": "6e454b700234a0b33df15e6936c1c27c643101a3c4253f5e41b8e8a48a9f7ab2",
+    "rust-std-1.54.0-wasm32-wasi": "052220fdf7ea1988b6cc6445f8ea58d2c29335feb442842014f161e618534331",
+    "rust-std-1.54.0-x86_64-apple-darwin": "3908ff438cdf39c3f46a103f3a0fa04a0d8add996c87e4290c80f1a766df6a04",
+    "rust-std-1.54.0-x86_64-pc-windows-msvc": "13f7595449308c4ffe79a6111d5fd2e7a4c6a56174d6c295437676e29951ce90",
+    "rust-std-1.54.0-x86_64-unknown-freebsd": "f504cad489fe606dd1a7d064253d6e0d0e5450674cfd941b8f848953efce99e5",
+    "rust-std-1.54.0-x86_64-unknown-linux-gnu": "487c51ac97e7f7deceae904b70e9bb031574dbeefe07b39b24e3fb00740962eb",
+    "rust-std-1.54.0-x86_64-unknown-linux-musl": "7cbe73472390e0e63d1812dd86d5024350e0e8dae36a6bf52585ad0136148818",
+    "rust-std-1.55.0-aarch64-apple-darwin": "bd364710331b34f454258b73e5cfc0583d3c0763ecce0994d8a990c1847604a4",
+    "rust-std-1.55.0-aarch64-unknown-linux-gnu": "e30063a259e32cd0e31baadcee82112ef840e0f654d5128dd79fc715ede92058",
+    "rust-std-1.55.0-aarch64-unknown-linux-musl": "f540bf8238b46cefc5490eb6e626f8712ff5a49d8fdb7e75e838a5c1e1b3046d",
+    "rust-std-1.55.0-wasm32-unknown-unknown": "275d7a1032f709d186bb8bd66a96f17f5c8d6c1a4c3b51b7ce60a4f3dccefdf4",
+    "rust-std-1.55.0-wasm32-wasi": "69696faaa29bdffc58a71707a4547a85a09199218411302afa7554073357f576",
+    "rust-std-1.55.0-x86_64-apple-darwin": "8888fb0a1cbc645f86e1551d27cc127697361fecab9cd414691e434976412733",
+    "rust-std-1.55.0-x86_64-pc-windows-msvc": "8507fe0f2059d68bc0cfabae1cc96cfc3d0357f04522942c5d4fdcdc1cbc23a8",
+    "rust-std-1.55.0-x86_64-unknown-freebsd": "522f4f75c50a0fde08d6235ed80c7cac30c922943954aad1e7c154cd8762ddd3",
+    "rust-std-1.55.0-x86_64-unknown-linux-gnu": "c07c5ce96b86364601c0c471bb85105e80a5e345b3e4b3e2674e541cc2fdefcf",
+    "rust-std-1.55.0-x86_64-unknown-linux-musl": "357b8f56ffa3858e2f32be837bd84e3d89403f17c55bf0c105f34a0b796bceed",
+    "rust-std-1.56.0-aarch64-apple-darwin": "88ae1a2da1c7bbabeab3bce392ed9cdf1403c1f6cef5a8bc9a6813e480127fc6",
+    "rust-std-1.56.0-aarch64-unknown-linux-gnu": "061c8a855696b3e23fb48ad69aa90e70ead825825e4cc02374d3cb1df4486258",
+    "rust-std-1.56.0-aarch64-unknown-linux-musl": "2a83ec23e14e0b578b636c3c95283c92fd034e8b56a564c043db3f8b746eeb2e",
+    "rust-std-1.56.0-wasm32-unknown-unknown": "3e0f1282549f09f9f9062f8fa8ca197eba5407c4422378688d78075bdfaf3358",
+    "rust-std-1.56.0-wasm32-wasi": "f819c096dcfc3fd0466eff346ea4291fe0ef86a08529b9be6843017c79256237",
+    "rust-std-1.56.0-x86_64-apple-darwin": "58c6fad6f09706f2940cd501a1d0dbd984ce4926000009aed313dd2cd3c1a7ad",
+    "rust-std-1.56.0-x86_64-pc-windows-msvc": "7d3961a5115f29738061d9c22e2472082a5e2de7bfe550a04a22180c3caa472c",
+    "rust-std-1.56.0-x86_64-unknown-freebsd": "e059d39f15cea58fd89d860a06504f48234ae2aff2c1eb5e4463b50367827ff7",
+    "rust-std-1.56.0-x86_64-unknown-linux-gnu": "3c314efa230f95f5d9e3357e5f915a4f40d2a21b10ba7b92fcc9036cbcd9fbac",
+    "rust-std-1.56.0-x86_64-unknown-linux-musl": "03b7a319a3d3e5f86278753f2780c7b3fa3f1b60bc2b8ddf6fd18a36540b8601",
+    "rust-std-1.56.1-aarch64-apple-darwin": "59fcdb16c264fce206a1a59261fc576f547fa0a807d3370b542ab25261ae5158",
+    "rust-std-1.56.1-aarch64-unknown-linux-gnu": "d577c25879cf160ec1a04d5101971dd684f9b4f87b3cb463a7521b676dc3df89",
+    "rust-std-1.56.1-aarch64-unknown-linux-musl": "444d5cb43bb82322562afe54c249c3d85b5b1cf215fcd0cfdabd2e657fcda687",
+    "rust-std-1.56.1-wasm32-unknown-unknown": "4e62beca963a5b8c98913dd10abc493126675a0a35c2817afdf6975a49cc1bce",
+    "rust-std-1.56.1-wasm32-wasi": "a7eaf9bf238671f7a54afe00cd76dbb354933e525ab5bceb10d156a2bc414dd7",
+    "rust-std-1.56.1-x86_64-apple-darwin": "a1cedfaea1508bf3bfc8a77d82d15c693b41e70e56fad930d24f21f0bce5052a",
+    "rust-std-1.56.1-x86_64-pc-windows-msvc": "ace5ea90e70b9d035b28b405175d52e1796fb1bb36cfbdead1048ff00e9ec1fe",
+    "rust-std-1.56.1-x86_64-unknown-freebsd": "1382799af56e1ec48cf3971f84122c9d445996422055b822d9d6226a31a20737",
+    "rust-std-1.56.1-x86_64-unknown-linux-gnu": "afd959b295e17640d1e94648278a944dc5f349ebdd9e59e2404729db0810c531",
+    "rust-std-1.56.1-x86_64-unknown-linux-musl": "88bfd0dce45d4321b0781550a300f90da5344dda20744219b6b23072b6cb03af",
+    "rust-std-1.57.0-aarch64-apple-darwin": "3b442d3f546524aef4fe8483c5ddcec1c5dbd52216d98aabc066883db31088d8",
+    "rust-std-1.57.0-aarch64-unknown-linux-gnu": "4c70901d1cbddec9ea99fbd62b20f454d30e1ffbb48a21169ac823b3f02a1fbc",
+    "rust-std-1.57.0-aarch64-unknown-linux-musl": "4f0c6533186b8fb596ee11b49bd6c9ffb76be59eb8bbdf26f25a47d297666c02",
+    "rust-std-1.57.0-wasm32-unknown-unknown": "3e0525d9e16f1a58e847080f2d3c02e275c2d5563b7980311e39382bb6c8441d",
+    "rust-std-1.57.0-wasm32-wasi": "391d814379cf117e927e5deb17bf44e964adee4f5f7208eaee1ddc8927da1fbc",
+    "rust-std-1.57.0-x86_64-apple-darwin": "c1eb892ddb50ebeed288b7aa8171ad46d62362bb26b2d82d2b463dfd45606dc2",
+    "rust-std-1.57.0-x86_64-pc-windows-msvc": "c3984148c561297f804238f6f1e4dd06302c6b3465d3744074016bc23a9f078b",
+    "rust-std-1.57.0-x86_64-unknown-freebsd": "1528a4bc7e3ba42da164bcc7b952dfa73048333c5b9254ce2d03db6bab6081e8",
+    "rust-std-1.57.0-x86_64-unknown-linux-gnu": "9140ad6f46a903345d4297a987ccaf37b9c5ca594cd6fd5a27d0be482116fe7f",
+    "rust-std-1.57.0-x86_64-unknown-linux-musl": "e59345c7ba6bde5e1d2950b846c097511998d5897c63a7cea078ece4b8507f5b",
+    "rust-std-1.58.0-aarch64-apple-darwin": "7c1d58bdc87b79f439b1083348a0e492305f8737ad1931755c26b2834a854f42",
+    "rust-std-1.58.0-aarch64-unknown-linux-gnu": "3a1283a2dce7abf2816dc70d622215f5769c416abf3e94dd94dd6a5d1109f506",
+    "rust-std-1.58.0-aarch64-unknown-linux-musl": "2e0589157f7f5055f4f295886f9161cdd239d845b7e021a0a59bf338facf9dba",
+    "rust-std-1.58.0-wasm32-unknown-unknown": "cb668772798a811de6e6d5823398abf888f29319bd3803621b0f4ff8c1693de0",
+    "rust-std-1.58.0-wasm32-wasi": "4d86cf175ebeb3002fa940447b52ff6fdad99f9fb2ba6a56e42ef961e685c3f5",
+    "rust-std-1.58.0-x86_64-apple-darwin": "fa89e9ab2e3645d6732811dae3828c86fbd65cb7447ec33c84137e61b168396a",
+    "rust-std-1.58.0-x86_64-pc-windows-msvc": "20738c0c92fbb59800926ab2fda5191b03537a3d6574ba4b6534de3ebc12d043",
+    "rust-std-1.58.0-x86_64-unknown-freebsd": "99016932b881df2a579d52761d4851ed538e34c39b47e882505892bb50d930bd",
+    "rust-std-1.58.0-x86_64-unknown-linux-gnu": "0517b0cb57a311bbe1997e9b87fc6bae1f9e1eadec4f7d97374740f17f890842",
+    "rust-std-1.58.0-x86_64-unknown-linux-musl": "10d911a65381b624cd1d33a913c9a2270355dbcd6db66b847e63f0f9b0f85f35",
+    "rust-std-1.58.1-aarch64-apple-darwin": "307f4d430f3491098b7d73db618408eadc22b0e290d2e22fbcf2909c5ec96c2b",
+    "rust-std-1.58.1-aarch64-unknown-linux-gnu": "1f81a91f29d1a5dd4bbedbb76be74582553bb363103bc390c2f8f1f26c2a24bf",
+    "rust-std-1.58.1-aarch64-unknown-linux-musl": "feeb863de2688b70b98eafaf7e707b2192373b649ad147aa07d1e95d8cde825d",
+    "rust-std-1.58.1-wasm32-unknown-unknown": "ef92a50952a03111c59745b8732f55f209da12e5dd8cd15072ad4ed96ad048e7",
+    "rust-std-1.58.1-wasm32-wasi": "09e3b15ebff0a68e83b36913e4711db5ffb4c8dd3d7fa827988c1bdde6b9ee32",
+    "rust-std-1.58.1-x86_64-apple-darwin": "aaa1e34c45394abaa943499e56047f6e678e42e7fcf5fe065000fb33559961cf",
+    "rust-std-1.58.1-x86_64-pc-windows-msvc": "b8c335eb2ac500f59f2259b3ac9095647566725ad133509732d3f4a5a7d53139",
+    "rust-std-1.58.1-x86_64-unknown-freebsd": "946c4bc834a89b30deb82664b04b67aee0fa65c232447b3adb4c29e89a559b4d",
+    "rust-std-1.58.1-x86_64-unknown-linux-gnu": "649bda48542f211d77afab4b71505572a4712b6b5c5bdee94533e2e7a9a832f1",
+    "rust-std-1.58.1-x86_64-unknown-linux-musl": "c4e56dfcf9d3d8466eb7d065af44763369df6e641a812a0a6974f94c98ef9a12",
+    "rust-std-1.59.0-aarch64-apple-darwin": "e70bd0c56f8f716238a1395c54dd9d993a3168e2764e404dc65553babf7aa127",
+    "rust-std-1.59.0-aarch64-unknown-linux-gnu": "81dbd37919f631f962ac0798111803eb8f06ffde608f0e5dd3682d701cf5566d",
+    "rust-std-1.59.0-aarch64-unknown-linux-musl": "e4f73617db73df7cb3b97984e38184f57292cc527654b52451293cd70f36f5a4",
+    "rust-std-1.59.0-wasm32-unknown-unknown": "d79f31c54eab23c24e245e8988efa2f73451dc8537d386c52dcc1d7a6db246dc",
+    "rust-std-1.59.0-wasm32-wasi": "b62d02df72e2129c64b35a5d531525d4f51f96eb550cc6705f618968218a7ed6",
+    "rust-std-1.59.0-x86_64-apple-darwin": "959af8bafbc9f3916a1d1111d7378fdd7aa459410cdd2d3bbfc2d9d9a6db0683",
+    "rust-std-1.59.0-x86_64-pc-windows-msvc": "fae30c5c9ac491380b556377fb0e804b35707118c5e69f8190debf828c9ad863",
+    "rust-std-1.59.0-x86_64-unknown-freebsd": "cf5e4303dd7c3b70a738a2336097c9f2189c8b702a89a8c453d83ac0dee4602c",
+    "rust-std-1.59.0-x86_64-unknown-linux-gnu": "3927fd7a094ba063daaf3163fa1b3b0b196968356845fe31c901a23ecc5048d4",
+    "rust-std-1.59.0-x86_64-unknown-linux-musl": "dfad080e9d86d97929f040a3e2a113a17d4906809c47e9ab6410418b492116af",
+    "rustc-1.26.0-aarch64-unknown-linux-gnu": "ddddaddb585b95d81854171ac4e02d07790505853cee3034f199c8b7897f32e2",
+    "rustc-1.26.0-x86_64-apple-darwin": "5cb67314656d16cf2a1bdc84213aaaf6afdb5811825c7afba916e2d42d3d641f",
+    "rustc-1.26.0-x86_64-pc-windows-msvc": "427ae4a43a901be288ff3a4dc85d3a14f7e95108cfdaae63e8dbb4a227e07cdd",
+    "rustc-1.26.0-x86_64-unknown-freebsd": "9499ce5b68d631f8345c387e1f59b21892d97e0acb5650deb61a34719310bd38",
+    "rustc-1.26.0-x86_64-unknown-linux-gnu": "7ca9a30010602aaf2244c376a3cc5baa89429d54da17b8ba1cb0cdfdc846cc61",
+    "rustc-1.26.1-aarch64-unknown-linux-gnu": "7a06bd5312cbe8bb19e526b4c9ab04de1628019815a566ce0ff9401515bc2c04",
+    "rustc-1.26.1-x86_64-apple-darwin": "e5f4291c3709b170fbeb17fab7fae50fe0c626dbdc5c42ddb1f342ea03acbad4",
+    "rustc-1.26.1-x86_64-pc-windows-msvc": "e84dca395837aa24b4ea87d46d06a333c2e87d0be5fc5259476a95fbcb05accc",
+    "rustc-1.26.1-x86_64-unknown-freebsd": "dc3dc36010d73349152e6158522e82830fda173007b9299b0a947c90769c54ff",
+    "rustc-1.26.1-x86_64-unknown-linux-gnu": "45bc1c30e0c473c42889f22b182ec6f0b0fc3be0825e1607c64933592486eb2a",
+    "rustc-1.26.2-aarch64-unknown-linux-gnu": "b09fea72e259811fcbc6aade942329bc4588356470765987ee37d6108a82f7b6",
+    "rustc-1.26.2-x86_64-apple-darwin": "5b0a3d94a4fa76ed28859123e35c09a91d7eb8ff65f40ec4c50dfa56ffed8ae5",
+    "rustc-1.26.2-x86_64-pc-windows-msvc": "15eb657747a86a4481501bb21e2dbcf56a06c0beea00e8677c86ef74b8812576",
+    "rustc-1.26.2-x86_64-unknown-freebsd": "48f20a8dc6bc54c90aae685d0c3fa2caf3677f1c4a4d0c53aee9d15588bd0735",
+    "rustc-1.26.2-x86_64-unknown-linux-gnu": "1ebdafe52b581a63cea217a036fd6e77706d2715ae9cfe10a8c715d753326004",
+    "rustc-1.27.0-aarch64-unknown-linux-gnu": "b58c0373df43623adcc990d36190ee157f46f6fba650d0242632f3df2dfbc425",
+    "rustc-1.27.0-x86_64-apple-darwin": "0b00c6971ef524f68b911f621d199e60c339c390b18e12700d55e012b62aa90c",
+    "rustc-1.27.0-x86_64-pc-windows-msvc": "22eeac4f4b4d91c28cf18c6a4a8b477091e6661e3e827c0b32355d52e634a517",
+    "rustc-1.27.0-x86_64-unknown-freebsd": "24c193213450ffacffebdd1413d77fc3c1ed00049cf1ede2d0f3f370dd86b462",
+    "rustc-1.27.0-x86_64-unknown-linux-gnu": "29f399a1a208ea3f27f21e57f2d832e9d801c397a986aaea17e3a2ddeded6c3c",
+    "rustc-1.27.1-aarch64-unknown-linux-gnu": "c48d19ff5474ce75ebbb97e1b26ca8dc23d38f635ae7a3e21b8a4139df5cfb8e",
+    "rustc-1.27.1-x86_64-apple-darwin": "747f616e07e5da9323a21c1cf9d76b53bb46094a68223d461a7333f26c714f19",
+    "rustc-1.27.1-x86_64-pc-windows-msvc": "76abfd523f876516e589f62a83eaaa6e55496745e32f2e9f3f87aca55da3e8b8",
+    "rustc-1.27.1-x86_64-unknown-freebsd": "9b199c21094f996fd9d4b620a5ff2c4bc5b8dab13e96bdf7c113291f601ec944",
+    "rustc-1.27.1-x86_64-unknown-linux-gnu": "a6bf6205b345b854d705d0028a4e7161a0f5b209e464130e7d135fa01a296dc1",
+    "rustc-1.27.2-aarch64-unknown-linux-gnu": "c1a5ddc6e40be5eef7afad8c126c6f426d07eb1a297902c7ef871279fdbeea49",
+    "rustc-1.27.2-x86_64-apple-darwin": "b5c5edd2094afd0a92ad776dbd12cb6ee37800b940437dece10229ccacd1f561",
+    "rustc-1.27.2-x86_64-pc-windows-msvc": "c00dde7df7475340f5574b09c86d0e19f6707f838bf95d2ff463a8f4d4d76d33",
+    "rustc-1.27.2-x86_64-unknown-freebsd": "66d739632574fa52e82b40aca0eb4cef7a38047ed67cd6a240d8798a3cf9b6a6",
+    "rustc-1.27.2-x86_64-unknown-linux-gnu": "ec3efc17ddbe6625840957049e15ebae960f447c8e8feb7da40c28dd6adf655f",
+    "rustc-1.28.0-aarch64-unknown-linux-gnu": "09d1fa08d7403495ca07565eaabfcbe6703e842b765a68d5110cf4e64e988476",
+    "rustc-1.28.0-x86_64-apple-darwin": "10a5bf35177508c72050149663ff679a770eafa8557c6be0052603ca1267ae4d",
+    "rustc-1.28.0-x86_64-pc-windows-msvc": "39871017768fe779dbffaaff8696baf0788bb9c4d6c4caa3d2564e1153ab2199",
+    "rustc-1.28.0-x86_64-unknown-freebsd": "5eeaa17844f87e59aab821dc98dd15a920df0d1d7da3ef5808d2c586331c92a7",
+    "rustc-1.28.0-x86_64-unknown-linux-gnu": "008bb3d714544bc991594b29a98a154441914c4771007130361bbadfb54143d0",
+    "rustc-1.29.0-aarch64-unknown-linux-gnu": "c7480c0b98ae84151ffa8cadcb06d1ed2a11a755b6619ac1b89e7c886e98b7ff",
+    "rustc-1.29.0-x86_64-apple-darwin": "3462ba7e841485f93251762ce0b36a3922830a1249e5d79d6d010ceb43e4ee3f",
+    "rustc-1.29.0-x86_64-pc-windows-msvc": "b27c38cb60092e9cac8afc4ad760349821e6b068d986e13ad46233b9676ab35e",
+    "rustc-1.29.0-x86_64-unknown-freebsd": "38f30c96f0fa7ebfe94cd2db57e9b99961feca0a09045dbc1e955404b5d7f40a",
+    "rustc-1.29.0-x86_64-unknown-linux-gnu": "229c51d51efc239e6eb9b428795bb7f57309f11287705dcba4877d5e220102a0",
+    "rustc-1.29.1-aarch64-unknown-linux-gnu": "784ea61ff852225be622141600c79621456f1ad9f9becdf7070eb0217b8635aa",
+    "rustc-1.29.1-x86_64-apple-darwin": "64b86c923786dfafe8bbb5fcbef0d854132f29f0bf635830cd2d95ff225d2317",
+    "rustc-1.29.1-x86_64-pc-windows-msvc": "2675bf444df8fe900b84098917db3e765c87ad3c812ef2a818c7e622d77db457",
+    "rustc-1.29.1-x86_64-unknown-freebsd": "ed9b2ccbfc6028ce2c73105cebebdb9f2e2332018c687951639176358bfed9a2",
+    "rustc-1.29.1-x86_64-unknown-linux-gnu": "b99324394ba20bd12efa9d30dad72b10747bd075f97c7a9fd0ce3f9394383fa7",
+    "rustc-1.29.2-aarch64-unknown-linux-gnu": "54a8c54f04dec72d7f8655ce1c3037dc23ded2f9ada26e7ea77aa45fc8b0d0c5",
+    "rustc-1.29.2-x86_64-apple-darwin": "d9c0dd8127ed632e27d751f051bca933578317ffe891e39155ae721bc1d3ec05",
+    "rustc-1.29.2-x86_64-pc-windows-msvc": "53dcf97ed9461784d713c5a413df7e8e5aa4c9158a4d5921a038b77b17120a17",
+    "rustc-1.29.2-x86_64-unknown-freebsd": "94fba7a7b88ca86c037a48376b7e09bb4ca66e1268fc8d664796cdbdee97c0fa",
+    "rustc-1.29.2-x86_64-unknown-linux-gnu": "b04146b09edc4bad0de7c8fa1a5a2aa4416d365c03c5962b8a5b26c7047b7cc9",
+    "rustc-1.30.0-aarch64-unknown-linux-gnu": "ccff6c6d8386655955265f586862314dd3b646bbeccd1369877f4343b1960a53",
+    "rustc-1.30.0-x86_64-apple-darwin": "d4fcbc61c7323e6fa1001ae268c5db1693ff07e5ef1ac25907138a2ee7bd8faf",
+    "rustc-1.30.0-x86_64-pc-windows-msvc": "2d2d1a51bb15794920a2f0cccf7fd2c8bfb037d00975e799ff4a4ac3b83032ce",
+    "rustc-1.30.0-x86_64-unknown-freebsd": "68a74949e34118406673cf8cc0098b011907c840890e0640aa3b145ce91c521d",
+    "rustc-1.30.0-x86_64-unknown-linux-gnu": "cc45058e9963d33ca28220e752d9e360b7e05f17e34284f5f8197738c3a88444",
+    "rustc-1.30.1-aarch64-unknown-linux-gnu": "f3569c0a74f07aa2e56bf93c9f2aaddf7434ce17f85d6d6ff854fb9245888bcf",
+    "rustc-1.30.1-x86_64-apple-darwin": "fd8ca09595e9d686aef9e3b94259500b482cf7a01de167a8c72a4f8d19a604f3",
+    "rustc-1.30.1-x86_64-pc-windows-msvc": "8ad1551132de8c766d2d7c66d9bb93a959ebbfa7d86c47f196227fea914583dd",
+    "rustc-1.30.1-x86_64-unknown-freebsd": "2f79e386bed201eb9b6ffa58240742617ec6006accb559dab7b6424f33b65b5f",
+    "rustc-1.30.1-x86_64-unknown-linux-gnu": "d84de208499b59e4a3c074f9f3f2fcbb26fb20d6bfd19262e6d5f4181ddbe34d",
+    "rustc-1.31.0-aarch64-unknown-linux-gnu": "1e480d8cadceff39ad39d30fe874bfd485386c98842f16423310cb2ada1923c0",
+    "rustc-1.31.0-x86_64-apple-darwin": "250fd3f3aba7d38c4af9682a12a37c733dbd6dde127665b0f493551e6c4aea8b",
+    "rustc-1.31.0-x86_64-pc-windows-msvc": "418abc285870ab4d85d53769eac229cd66b7fc7cdaa6e73699530e88ee5dfaf4",
+    "rustc-1.31.0-x86_64-unknown-freebsd": "9ec40454e22e3494b9859c03e37e8851077f897845bcf838d69d4393900e7b33",
+    "rustc-1.31.0-x86_64-unknown-linux-gnu": "5c4581f0fc05f0f5076db6231b0c1a4d27eb61c0b36bfb42d97243ad8f4e43a0",
+    "rustc-1.31.1-aarch64-unknown-linux-gnu": "315ea9c981e4320a557f6c75b58242c0598a90316f610b4dfef5d06e82b927f2",
+    "rustc-1.31.1-x86_64-apple-darwin": "e3f9c5ccd0e6e09da8012f30ee9a1880efebc0c039cc1f3866cf50c984be16a7",
+    "rustc-1.31.1-x86_64-pc-windows-msvc": "0320b7544de463d4444c6445fd2e23044e28fde1173f614145a72a4bcfc6ccd9",
+    "rustc-1.31.1-x86_64-unknown-freebsd": "fb38ad94976c273c0fb95d0b5ba2d1ce90684e58fa06fafc9f8050ba00559f50",
+    "rustc-1.31.1-x86_64-unknown-linux-gnu": "77d47ce7e27a146e4301f11befd43f3fc5ac195ace0dfc07ac8154f130b057ea",
+    "rustc-1.32.0-aarch64-unknown-linux-gnu": "193cbe67161e20a0bf4eeb8bafeb302f3e61a59ca939a0454fc3fbc76e9524cc",
+    "rustc-1.32.0-x86_64-apple-darwin": "0334c4568f09cae984e53e4a3f4ff207e2bcc50fce13ad32b8eca89f014e5e61",
+    "rustc-1.32.0-x86_64-pc-windows-msvc": "a7799495d3032c5ad6b5f712f7d7a9538f695c6d8d2e5258c0f7aadac8cea1d4",
+    "rustc-1.32.0-x86_64-unknown-freebsd": "a14a0e288be8ce894a85810151a2eb70fc86afa36e4a5fae4e903c744b888687",
+    "rustc-1.32.0-x86_64-unknown-linux-gnu": "75c31f32e19548c1608611d08b82b87560e02f15caac7b2663a8189a4609977c",
+    "rustc-1.33.0-aarch64-unknown-linux-gnu": "e23141cc65d1d8e3957a96f3a601bdb7a9d09026ac20396aeaebd2613ea0d08e",
+    "rustc-1.33.0-x86_64-apple-darwin": "ea1f0a95015bbefba9eac5890b12ee2887f464822ab579c8bbc2db3023c6dd08",
+    "rustc-1.33.0-x86_64-pc-windows-msvc": "b935a78d072b9ae91ff8ddf9155df95d77fd8a1c6293e39df3c65b18d860320e",
+    "rustc-1.33.0-x86_64-unknown-freebsd": "8bfc7fc50c50294cf4ded35360b41b590180401a0d2e84256f5931c7c1ff35cd",
+    "rustc-1.33.0-x86_64-unknown-linux-gnu": "54a342f718b712d8a17fd7878ebd37d22a82ebc70b59c421168cd4153fd04c2b",
+    "rustc-1.34.0-aarch64-unknown-linux-gnu": "364328a40c7aa5749be80b13a14466149a559205e34aef3d8823dc2580f55921",
+    "rustc-1.34.0-x86_64-apple-darwin": "2044d44f01a8aa7fb3382f35fc839facfde4fc1eb6f951ead42aef954e317088",
+    "rustc-1.34.0-x86_64-pc-windows-msvc": "371f9abd2bc615b339dfd606d93e6b4892594fd86084d513e07a9f80ff21a828",
+    "rustc-1.34.0-x86_64-unknown-freebsd": "522662f147d0550e4f4f49026b4ebcc5e05a0935fa88acc9b99da5d7435755aa",
+    "rustc-1.34.0-x86_64-unknown-linux-gnu": "5852e84dd30e4a552a7cd4d7c0172648d7ffb4d9ac7078871adbb902c183ffc2",
+    "rustc-1.35.0-aarch64-unknown-linux-gnu": "dc06d77e6cdc06693d3b87ce473f151c96bda2c1e5dbba8c0354c54990c64fc2",
+    "rustc-1.35.0-x86_64-apple-darwin": "5b2fb7581332f349c041860479ffdbfec0eebf87fc3016146836b8868afc3ae5",
+    "rustc-1.35.0-x86_64-pc-windows-msvc": "df4f94d29d10fde2486d9fac3247a566d99a2b7f97fa6ebd416f308b804f7693",
+    "rustc-1.35.0-x86_64-unknown-freebsd": "d3b5a6cfa41264e1873287bdb89892a7edc40333d581f468890c68336f50a601",
+    "rustc-1.35.0-x86_64-unknown-linux-gnu": "bb3a07a1f2fdc3eeeee25fc40131d3f05494e3838dfd4e9275475ffc500d7a9e",
+    "rustc-1.35.0-x86_64-unknown-linux-musl": "a975395127a2abf727a7c6b6ed2656e90368b46c5e6ccdc53fd50acca3cd3f94",
+    "rustc-1.36.0-aarch64-unknown-linux-gnu": "62e40e0677032ae0cd91a7f8b4450dbaaf5223050a05b28a9174802d09691da6",
+    "rustc-1.36.0-x86_64-apple-darwin": "97568272717ffa62dbf4459dff6086e69c808df252a912146e28468412667013",
+    "rustc-1.36.0-x86_64-pc-windows-msvc": "4c131f68eac74bc20315eda097578c43de2b695445739462a4b273f90a131ffc",
+    "rustc-1.36.0-x86_64-unknown-freebsd": "c2dd0cec49b054ed9439762fb31555b8df9a3d81747b194f7d3afbc6d8adb8de",
+    "rustc-1.36.0-x86_64-unknown-linux-gnu": "7c149fa1695b41e8e1edcb95dca199522889f119be99f922741084d50470a9e5",
+    "rustc-1.36.0-x86_64-unknown-linux-musl": "913b7097e13c4e616edb8f83a3a976908c8c12295472f65a5682465145ced552",
+    "rustc-1.37.0-aarch64-unknown-linux-gnu": "721ba21dbe9b350a8c50a4c783c76ba3f6926525480518851dd6ba92ecdb042c",
+    "rustc-1.37.0-x86_64-apple-darwin": "00d4d15b4d9a4d188e0db8bbc17cd5f0c3c3a87ad681e80ef15580c0d5bd4ff3",
+    "rustc-1.37.0-x86_64-pc-windows-msvc": "790bdb5b57f397d7481151ad8715f7ac3f32b343efaf2922650f4fc6e374d7d7",
+    "rustc-1.37.0-x86_64-unknown-freebsd": "a4dd357a0b39abf1ebbe8a0f64973c3b0c5bc527e374c12afe51266279fc1ca6",
+    "rustc-1.37.0-x86_64-unknown-linux-gnu": "c759b318f333639a45f29c1551ca7ce55b1bf64e0fc3a3357d6b9356885d1626",
+    "rustc-1.37.0-x86_64-unknown-linux-musl": "1981b67c0cbcaf37f40ee9576d6d1b9a554019e571fc4c49ee9457cf011e0f75",
+    "rustc-1.38.0-aarch64-unknown-linux-gnu": "0c787eaf01b5779b5a0c12bd0573901cf1b58e5e484ad44c3530b7ed51754d15",
+    "rustc-1.38.0-x86_64-apple-darwin": "ac34aee5a5f67003b8f7f857ddb1fa68f89a32680a591ab77561282721b75256",
+    "rustc-1.38.0-x86_64-pc-windows-msvc": "6e00ee5f34c552c1b9fafec3b7a1330140c820a2ae4bd4213d2c4f135341a88d",
+    "rustc-1.38.0-x86_64-unknown-freebsd": "1d99318bbdc947c6dc375215f0eddcd767348c309811cd141e5d18e17d5aaaa4",
+    "rustc-1.38.0-x86_64-unknown-linux-gnu": "790a611695fabd12c3a141efa58b3dc5913d749947c1a95d3f5b6eb5476ee612",
+    "rustc-1.38.0-x86_64-unknown-linux-musl": "bb0166cbb1d31bcb09d79224e7ac43a80d9448b7199b5392a3852b3ec71840aa",
+    "rustc-1.39.0-aarch64-unknown-linux-gnu": "c64fc482404277fdb160a4b593b0be5a1b0c32d985464595015295321d111621",
+    "rustc-1.39.0-x86_64-apple-darwin": "9347ffb47e936fb44666ada525f8bfb86758a719e7c0330e93e17bbd5f3623be",
+    "rustc-1.39.0-x86_64-pc-windows-msvc": "9a94785fdb473079d02f32bded6691322688001dcc16f5bfb582c1d181d3ef67",
+    "rustc-1.39.0-x86_64-unknown-freebsd": "3714bf7bd4163a3bfe18291d49acaeda02f4bf2beb9fe36c520d2ecdc29ca031",
+    "rustc-1.39.0-x86_64-unknown-linux-gnu": "333399dbf96dd6b8a9dc9cc56b1cb5d8aac2296b4e4aa857bd59d906d6df6fa1",
+    "rustc-1.39.0-x86_64-unknown-linux-musl": "07a9705dd77c6859ef921389dc6a958a297030e53571fe015163c79aa93d1e43",
+    "rustc-1.40.0-aarch64-unknown-linux-gnu": "8981d500261ecfec93c4b52e8f96a81c705b56ff9317d63e0363d11a72ee09a0",
+    "rustc-1.40.0-x86_64-apple-darwin": "f45bb00a9a59ca819a8266e9de77f7232f4b704d64f1c45d3870e2db4f646a77",
+    "rustc-1.40.0-x86_64-pc-windows-msvc": "16299638792b7bffb63ca20674a7196a33d1fb25e91083b90f8015be010eec19",
+    "rustc-1.40.0-x86_64-unknown-freebsd": "65810804d3e4cf8f845978c6226f8e23d77a7ccf35ebafdd5f8dac027627f396",
+    "rustc-1.40.0-x86_64-unknown-linux-gnu": "5085a26abdc932fd9339aab2078084f9ab654f8298ad9f301611ac41ba8eca19",
+    "rustc-1.40.0-x86_64-unknown-linux-musl": "acd01559a875b57f6fc7e27beafd8d011f8295c627ab276d814700082088f2ed",
+    "rustc-1.41.0-aarch64-unknown-linux-gnu": "9d994935f92088c968f520f558a88b140bb7d60e917fc4ad69019e2b830b1db7",
+    "rustc-1.41.0-x86_64-apple-darwin": "25ee8865e21007c282cd1f3457c3bf932591337c3044e55ba574fc988bead3ad",
+    "rustc-1.41.0-x86_64-pc-windows-msvc": "b338afb534be113f179252f8de29195e201dcd8bf4053b1d5e8eef928c457ca3",
+    "rustc-1.41.0-x86_64-unknown-freebsd": "de3386f79a0e261b8f6133dc0d5a7d51b70ad73dba5a14dd30204ac285d04f3a",
+    "rustc-1.41.0-x86_64-unknown-linux-gnu": "531b4cc77cc25e960aafa2ebaee073c137fceb0004447c6b7274557281c62a6d",
+    "rustc-1.41.0-x86_64-unknown-linux-musl": "18c0f6d263d3a54a6842e2feab7c90ce5d8e5136b67cedabb98756f029122c8a",
+    "rustc-1.42.0-aarch64-unknown-linux-gnu": "612c10793852fd0c2e52b30f3d50dd6aef6f8181032b820eddefc93e3bf4d97b",
+    "rustc-1.42.0-x86_64-apple-darwin": "778dea93d7e46261e2c06cadec35b68f9857604f279ce6fbd1b37c1a89634625",
+    "rustc-1.42.0-x86_64-pc-windows-msvc": "d132f99df49cb0d421f6d8948a268d4eddb1ae23e0af2641272438998503708b",
+    "rustc-1.42.0-x86_64-unknown-freebsd": "e6e36a7df9886b18cce32752f5ac7a8da6977c6a1878fae696340f3843176fe5",
+    "rustc-1.42.0-x86_64-unknown-linux-gnu": "4242a728b850bf6e74db9a95c68e8ed316fa4813b38e6b8bc296396b5f47ea5a",
+    "rustc-1.42.0-x86_64-unknown-linux-musl": "60945b79fdf8be51c87967368245380a64d0d331ef1aefa778712f3695028c39",
+    "rustc-1.43.0-aarch64-unknown-linux-gnu": "99f26a2b4376fc08203d129d65e15f01b2630db40dd2d4d6a7b917df8d512e72",
+    "rustc-1.43.0-x86_64-apple-darwin": "3723b8194e38d7238262b4cc49762a22037f53f58ab1df199c1d710dad5728a5",
+    "rustc-1.43.0-x86_64-pc-windows-msvc": "c6d1aa60cf2056c4fb35a5a197fb4e1a42887eb4ad1615b00398524ff78ce74c",
+    "rustc-1.43.0-x86_64-unknown-freebsd": "69d572e80e13da85599557f662ce71909823194c874eea0fe91f82da0958fa68",
+    "rustc-1.43.0-x86_64-unknown-linux-gnu": "950b323044ae9a7932b697a2e4f4f62b59248f58faa320e22dc20f8ad9521f6b",
+    "rustc-1.43.0-x86_64-unknown-linux-musl": "7b9ff3fdc2024d044f19bfd5353441fa5fe7409c9ca4883726b5c8fdece3a7a6",
+    "rustc-1.44.0-aarch64-unknown-linux-gnu": "b0fc4cee7119c10f79fe2701ca0d19ab738bd20954352ae5b1dcc4c6f432779a",
+    "rustc-1.44.0-x86_64-apple-darwin": "4fd09afcae85f656d4a545ee415e19546e03e34f1ca23be5eaa68c489e3186ab",
+    "rustc-1.44.0-x86_64-pc-windows-msvc": "0b3aec27d86034cbadf4adbaf36308bcf98d97c0979d162ffccf4328fb4f96cd",
+    "rustc-1.44.0-x86_64-unknown-freebsd": "6f3c4e16bbda8719e5c07dc687e84a7236e097da55c4fabea13ef1cbd6a30c40",
+    "rustc-1.44.0-x86_64-unknown-linux-gnu": "52671652e7045df0702d8f2e8af60bf6f20da3e3a5db1aa6022bf9545e914449",
+    "rustc-1.44.0-x86_64-unknown-linux-musl": "71440388e5e4affe11fddf3c3a706ac6f129d9ea47717894b586290e553223fa",
+    "rustc-1.45.0-aarch64-unknown-linux-gnu": "b1ef2ea19142d851f2ee6936cd46a30ec8f157ba53048bc2748279d1e9e0ad17",
+    "rustc-1.45.0-x86_64-apple-darwin": "fd17d99c3e827f0b4f01b9122d4bf2fca0f1144827300a1eda93718d8642b39f",
+    "rustc-1.45.0-x86_64-pc-windows-msvc": "f65fb383f2c6f979a19acbd4e099e6eea8addc0e76f1fd988582dfc0daa4a121",
+    "rustc-1.45.0-x86_64-unknown-freebsd": "b5d263c53320f8a5dd5daceac1e60da172fd21614ada67f584565430d9d1c9c6",
+    "rustc-1.45.0-x86_64-unknown-linux-gnu": "3ef2fcf818c133c3e9957441917b23ea536805efd0ff9ac6ee0bea349d703a90",
+    "rustc-1.45.0-x86_64-unknown-linux-musl": "596f04e0774225ca85b5c99575854dd66973854ebcdd0b7a60d3c2cff4d415db",
+    "rustc-1.46.0-aarch64-unknown-linux-gnu": "41239ece19c79250a205e5b2fae60b242bba4bf72b687bccc88f011e66a872b6",
+    "rustc-1.46.0-x86_64-apple-darwin": "f690b375df7b1399e5baa69b64932e3e4a3f2b651e5ef2ebc85509bee777a9d9",
+    "rustc-1.46.0-x86_64-pc-windows-msvc": "56badce580b65f59d676b20b4e5f138969e5039182b7f6052ac7da9d38bd0aca",
+    "rustc-1.46.0-x86_64-unknown-freebsd": "e76d3e18d1826753395d881bc37be3d43e9ff8d2d34d49d7ed6105f228d56284",
+    "rustc-1.46.0-x86_64-unknown-linux-gnu": "4c0c740cfb86047ae8131019597f26382a9b8c289eab2f21069f74a5a4976a26",
+    "rustc-1.46.0-x86_64-unknown-linux-musl": "6ab2664edc93122b7a93a1b72025e869d088445af65d3df286258c3860090114",
+    "rustc-1.47.0-aarch64-unknown-linux-gnu": "2e143bfa59eca5c3f3e995c5997ae55c7defe824fb4dbe7e77896e132f42c24b",
+    "rustc-1.47.0-x86_64-apple-darwin": "4773ad46b912c859984f1e4466e506dd8102603d1ffcd8b63cfe7522f49e5987",
+    "rustc-1.47.0-x86_64-pc-windows-msvc": "f2010e4500602d0efc431c0853692733415bedb58652376023d7d6ac204f8c7c",
+    "rustc-1.47.0-x86_64-unknown-freebsd": "811f298c07fb32a6a01f9960f2d7dc403f6f288a3f475ed9806648e2cc5938ca",
+    "rustc-1.47.0-x86_64-unknown-linux-gnu": "d96be0ae1deada01f41372ab2c2f485a9f8625069aeaff33c5b513061e9706d4",
+    "rustc-1.47.0-x86_64-unknown-linux-musl": "4c6979e2b01fc8da0f83b30e9ccf869f692ad84cf517e300362624d9eaac8635",
+    "rustc-1.48.0-aarch64-unknown-linux-gnu": "9c83a5d18f6ca913eeffd78c53913da288b171ff245137b646a8fd280fe72340",
+    "rustc-1.48.0-aarch64-unknown-linux-musl": "eba49211f2e0aae157e18258edacb3031dc8b4bb6db0bca142c919d9042c7ba4",
+    "rustc-1.48.0-x86_64-apple-darwin": "846f45f9bd6676e9d1f6758279b48e32564ba23773e69aa89692dbc123dbea5a",
+    "rustc-1.48.0-x86_64-pc-windows-msvc": "395b2a8e6824b3e56a8a9b4598273be5410b4ea64e92c8aeaf900d9ff21f470f",
+    "rustc-1.48.0-x86_64-unknown-freebsd": "fbaff313c2423f1ababc9792332560ca0e3749abf3749e7eb5289bc6515d9424",
+    "rustc-1.48.0-x86_64-unknown-linux-gnu": "aa4a96b010e0d4573e6a1fec230beaadaae6cdce2bb4befeee7b1c081ee9ef8c",
+    "rustc-1.48.0-x86_64-unknown-linux-musl": "5513813bdbd1aa5e4c4a0a0e680953b72d24829595920fec4e69da3682abdc0b",
+    "rustc-1.49.0-aarch64-apple-darwin": "3e8c0c9101f27623f7607f2d8acef5f28dcb2bdfcded56f210d9d370cf9a9c06",
+    "rustc-1.49.0-aarch64-unknown-linux-gnu": "b72699cdf74c03ccc0aabab937a69807f2ceb5861f3508593e1c222190c4efc7",
+    "rustc-1.49.0-aarch64-unknown-linux-musl": "b76b7f687ffceed03a86e69dafd251e8e069c31c31dbe70c0fcad1ace5398956",
+    "rustc-1.49.0-x86_64-apple-darwin": "09333f9aacb9c5959e2a2798d7e283cae674255f063a35ea28f91595caa0a78b",
+    "rustc-1.49.0-x86_64-pc-windows-msvc": "800b7571438850074aeb0fb9a0e7d890c6785f9f4823b3052b9b0b098bb9ddd4",
+    "rustc-1.49.0-x86_64-unknown-freebsd": "66427837606aba2cda99d4f52161bee1086e98b226a5cb99be8e9a7bf896495f",
+    "rustc-1.49.0-x86_64-unknown-linux-gnu": "42300556b987934e5e4677972c1dfc57eb07731dc62fa9f4f561935a1c84ed0e",
+    "rustc-1.49.0-x86_64-unknown-linux-musl": "4c56ed1fcee28a6f35c98d14edd34a33a60f52ac583c98313623760de093bf7d",
+    "rustc-1.50.0-aarch64-apple-darwin": "3abc090591fb7fd0a292eeff4cc6a029841d39b0a768eaf1f0b9e4e06cba8ed7",
+    "rustc-1.50.0-aarch64-unknown-linux-gnu": "9afe0e968da845981b463beb75f91d6da0d4de5443d1abb6002b75a8cf066ea7",
+    "rustc-1.50.0-aarch64-unknown-linux-musl": "abafb6bb1d2f065b72b43331e6cb00f3c98c78af00f261e1c53828c26528a078",
+    "rustc-1.50.0-x86_64-apple-darwin": "3637ee8d8bc0f8e922b1f9ec7b6fc00b6efcceae97c337d205a3bc472be7b936",
+    "rustc-1.50.0-x86_64-pc-windows-msvc": "d7f7607c9cd3e137a335904e1186345f4328a971588ee8a54838e32a35a38e3a",
+    "rustc-1.50.0-x86_64-unknown-freebsd": "916e616188638738ff217a047b3fbe372d9ad3734bb466d0e56d2fcefd1da5c6",
+    "rustc-1.50.0-x86_64-unknown-linux-gnu": "160a91a3f545f96b2b955cf48811080d8e0accbd9d9a9732b080e1ffa72113bf",
+    "rustc-1.50.0-x86_64-unknown-linux-musl": "528d02fa77fc0da26904ff10da2d6f94c6da618c323b37247b49fe28fd950240",
+    "rustc-1.51.0-aarch64-apple-darwin": "110db4985d7cb18ce6879f34fc02422f5f074b3a2b40b62e6bfd54ceaaa56d33",
+    "rustc-1.51.0-aarch64-unknown-linux-gnu": "b63b21d56cab87133c9cd149f7c8ca3b3399a877cb16496a86f7a87d8b15c784",
+    "rustc-1.51.0-aarch64-unknown-linux-musl": "58305d3fffa1662114587a6144afff9a872496aef6073b23dc5da9676d315d5a",
+    "rustc-1.51.0-x86_64-apple-darwin": "abca027d4e45870ac97f220e5f60f4e849dd53f575f902046952a127da739aa2",
+    "rustc-1.51.0-x86_64-pc-windows-msvc": "a6fee78393f3ee78bc81b5437122f7fd220d8d6686c9cfd41848bd699c9758f4",
+    "rustc-1.51.0-x86_64-unknown-freebsd": "572e7c13bb5951a12a9f6f422e636da8468747d29ab6901ef3b5b03932482e1a",
+    "rustc-1.51.0-x86_64-unknown-linux-gnu": "6b1298ef220302a33cad21fad7c8e1535264872b18e2ece733ac37ed31571dda",
+    "rustc-1.51.0-x86_64-unknown-linux-musl": "77614b115eac2ec975f29a8e2d60d8a77834f11689ff6b0d94eb74d4999df285",
+    "rustc-1.52.0-aarch64-apple-darwin": "9e17debb80c85695aef2b76f1b4ff3a10ab40947b386b2590fe168c4ba77ea42",
+    "rustc-1.52.0-aarch64-unknown-linux-gnu": "cbfec2d4cfd38a04e1945beb4736a6ad2eb22f3a18743865158c4e0a4da43450",
+    "rustc-1.52.0-aarch64-unknown-linux-musl": "fdf8be2fd4c4505155f81099e171fca5300f14cd1a343b4e11753bea99f2764f",
+    "rustc-1.52.0-x86_64-apple-darwin": "abed71e08d05a47f7a54495212ef67e020cc61edd6c90cb1589bb4c7f771a821",
+    "rustc-1.52.0-x86_64-pc-windows-msvc": "bcad3eaaac6f8bc117346047b3efa088977927ca668477b6e51cd037428ceed2",
+    "rustc-1.52.0-x86_64-unknown-freebsd": "5883388f0d1abc7e187d03bb213a4f34b8487ae4b665d9a76acd80c86fa5d3de",
+    "rustc-1.52.0-x86_64-unknown-linux-gnu": "76f16908c37c719abc1cd28e9cb4cd484aa88ba00152b2de3188b6ce86eea848",
+    "rustc-1.52.0-x86_64-unknown-linux-musl": "13e1ef7a3db7a90a2756e423cda10ae0b95510f041d543d8c00a91a2ffbb68dc",
+    "rustc-1.52.1-aarch64-apple-darwin": "d9f76477db98aebcbfd5ebbe4ce5c3aff30d7ac0185b25cec27e4ecc376ef4b8",
+    "rustc-1.52.1-aarch64-unknown-linux-gnu": "5218780009126b391786280f76b98aea743fd7cead8d48befc03791c095f88d6",
+    "rustc-1.52.1-aarch64-unknown-linux-musl": "a1dea60ad703c424f99becef772b97ea3966974002427ad8baf3ff5473fd7ada",
+    "rustc-1.52.1-x86_64-apple-darwin": "bc896a1c701ca10328671710c4a06ec4774b398cdeb64cf55fcf247f31dd275f",
+    "rustc-1.52.1-x86_64-pc-windows-msvc": "1828ce5c7ca28e7cdc9cb75105dd3489ea1e3648f800d3db0e99c248292d816e",
+    "rustc-1.52.1-x86_64-unknown-freebsd": "2de1df845045a8c6dc3832e7d615c9124c52eb5626b1aff1219e66fd3116623b",
+    "rustc-1.52.1-x86_64-unknown-linux-gnu": "52002b050485674e87fdd72c7b49dac8783dfa36575be7e6265a69b4e66f8570",
+    "rustc-1.52.1-x86_64-unknown-linux-musl": "195711077d44392a13e57c6695489e71cf811538eba02758dbea7c4ca2a72047",
+    "rustc-1.53.0-aarch64-apple-darwin": "a7f9c48adb4062c43bfad8fe608551c98d538529cbd13cb979578532a91edbe2",
+    "rustc-1.53.0-aarch64-unknown-linux-gnu": "a54267708a1e80bab2c0a919284b9387f4b70ca61a96dce7544b2c8001adc5dd",
+    "rustc-1.53.0-aarch64-unknown-linux-musl": "b26c35cc651c9233c58d08c12c076413a9637875a7fceef3f6b582629e169282",
+    "rustc-1.53.0-x86_64-apple-darwin": "ad3d181deafb4bfeaf3d313828b258b89ad2fece3623bb4c4488e282db802e39",
+    "rustc-1.53.0-x86_64-pc-windows-msvc": "27b895346c458c141d1cd277b3e87380ad3e304c62c7240d778a0cd3dc245581",
+    "rustc-1.53.0-x86_64-unknown-freebsd": "304eb5d1b4a8a98fb67cc1a9599c1c0ef7553d939945a6a80d768e3b69ff8c75",
+    "rustc-1.53.0-x86_64-unknown-linux-gnu": "c2c24b41602a589886f87276d4d46e42efddbad820917dc4dcbf6625cdf9ff52",
+    "rustc-1.53.0-x86_64-unknown-linux-musl": "6ab5694ac8ed7ccb79b7689e5dcf9198ddb937e123d31289e7b385bb60b3848f",
+    "rustc-1.54.0-aarch64-apple-darwin": "f18bbe09d8e08be5753e5f536ddfe15d4141b3ce968a2809a9869c91d492292b",
+    "rustc-1.54.0-aarch64-unknown-linux-gnu": "595e8db56e68247ee3caf29f6a3d3c72d7955ed45f1291e7e596d63923427a86",
+    "rustc-1.54.0-aarch64-unknown-linux-musl": "02360abef6aebef211a3e6fccfbc81f27c83e930c3291f95e033c8c9eb6c07b1",
+    "rustc-1.54.0-x86_64-apple-darwin": "b3ac970d31893a192c8ec46fd6c9b8409751246cba029a212c4cd84115086a13",
+    "rustc-1.54.0-x86_64-pc-windows-msvc": "9fd8ed58b28cc6554dc7ae17e8b96770cc4736460c4a0047c78fb7ff54d53f10",
+    "rustc-1.54.0-x86_64-unknown-freebsd": "a2974a15b2b284c09eeac39396728544700fdb8689e8b662ee062e68daa0b554",
+    "rustc-1.54.0-x86_64-unknown-linux-gnu": "cd4c1c5db3b8ca3f76fac42d209e83640794eb8c2bbfb71b71e5f93b584d159c",
+    "rustc-1.54.0-x86_64-unknown-linux-musl": "896b4eb229259005410311a29587aaab4ed7d5d590d810b06abd7601a004a953",
+    "rustc-1.55.0-aarch64-apple-darwin": "4d782c947f1a35f5fb60799f019b4b82ad121a017746c935ab37fbd105c66c8f",
+    "rustc-1.55.0-aarch64-unknown-linux-gnu": "31dbbc1395f5a545c114e778552159713977dec423bca5705bd4c92ee3840cb1",
+    "rustc-1.55.0-aarch64-unknown-linux-musl": "a5170d72af554b1d39a0db46cb2bd55911132705e3cf8e38d16a382f3b9d4215",
+    "rustc-1.55.0-x86_64-apple-darwin": "7d1197687c72d4c72ae04905b96a7205ec4ad7c9da0231ea6f3bbbc8399adb84",
+    "rustc-1.55.0-x86_64-pc-windows-msvc": "2cb681fa074386af8dd2cc6c79b57e1a8048acb1dda18e04fedff1c2dd84d70b",
+    "rustc-1.55.0-x86_64-unknown-freebsd": "ad50ba2c87acb59020959df594aadc207f4fa527b2b2cd8849f3b1d3f666986f",
+    "rustc-1.55.0-x86_64-unknown-linux-gnu": "9da098b2df01124f2c4b9789767151521f4bab98f50befdc75a691cece0c0d00",
+    "rustc-1.55.0-x86_64-unknown-linux-musl": "f7c1fe2393db842630b23ecf6164fac471b11235fdb62a35a86e7cd3cf8d749c",
+    "rustc-1.56.0-aarch64-apple-darwin": "c588dc2cd352eaf27ae74ee593bd0aaa65ac2742416c714f5827f395bb7c19df",
+    "rustc-1.56.0-aarch64-unknown-linux-gnu": "eb7283729bc4c336aa23b020489e8feb78eed70831213ee2e4121ce7d6ac33f4",
+    "rustc-1.56.0-aarch64-unknown-linux-musl": "e312187386bfb39fde04ca007faf656179e8c2b1bb1a0d59007db7a247b54b4e",
+    "rustc-1.56.0-x86_64-apple-darwin": "a724945de2bb0ba78e56217ba02f67ad0cb07a01c2438b01b91f85fb94d273d2",
+    "rustc-1.56.0-x86_64-pc-windows-msvc": "1034b2f6150d892649c1eb8fb10dbb4228ca2010f88720795e6a12696cab369a",
+    "rustc-1.56.0-x86_64-unknown-freebsd": "4e7a2f62ef2873b3bd45749133c1690c4b0e037af5a586e9ea691e480f8d2d40",
+    "rustc-1.56.0-x86_64-unknown-linux-gnu": "aa66db89c3f89325e40ba0bfe481f4d631559884ae4812c3c3d091d80ba7c245",
+    "rustc-1.56.0-x86_64-unknown-linux-musl": "5f7ed6c289b56c129d6dbb407348f566caf39cfc5db35a4b6253cf514940482e",
+    "rustc-1.56.1-aarch64-apple-darwin": "fcb2c2e46e3cc7e7cba3abbb78ba87131aea56770145f8d97944b675a491312a",
+    "rustc-1.56.1-aarch64-unknown-linux-gnu": "9e7461908d0b3e6f4bbb158b71d85e536c186fe571c9960f8ef4300328b25a11",
+    "rustc-1.56.1-aarch64-unknown-linux-musl": "1e913b7f39d0f478c48ff9b9dd6a05dfe67a6ad58e478509cafb20e106512965",
+    "rustc-1.56.1-x86_64-apple-darwin": "876b9ed13a71ada3c00878c6006d837b852973cba84419753445c8a8a76efe00",
+    "rustc-1.56.1-x86_64-pc-windows-msvc": "709fa5ad9723e233025ab0cd142b628cd8a4bb8d11fcdbb97a779d78a60604e5",
+    "rustc-1.56.1-x86_64-unknown-freebsd": "b6a440bf5c3b1e4930effc07c6e50bf03cc44c0465f0c379d626b800f4971700",
+    "rustc-1.56.1-x86_64-unknown-linux-gnu": "d09557a497a4f3b0726cae4c8e193843e403c80615f25f6ef740c79d7e4c122b",
+    "rustc-1.56.1-x86_64-unknown-linux-musl": "b49ef5d9d8a2c49e48dda8bf08fc5a95ac87095a8895df9dbce0ecfb1a97c70a",
+    "rustc-1.57.0-aarch64-apple-darwin": "cfd28be33d8669c85dc177775de6c4aa94289bba7cc65b90cbd2d9cd5486c860",
+    "rustc-1.57.0-aarch64-unknown-linux-gnu": "91f1e29387fc53430592985b0620c8587e4aacc8ac582de4ef96c45c9ae930d4",
+    "rustc-1.57.0-aarch64-unknown-linux-musl": "e5289c930ed72c08310108f543deafc319c27389523c6c6905fa35283e9ab725",
+    "rustc-1.57.0-x86_64-apple-darwin": "4417eea141bb915f39305cf2d812579f503422fa2e712eddf11427ce91c48294",
+    "rustc-1.57.0-x86_64-pc-windows-msvc": "073bbc3f8f71fb20bf6c7bd2e4cf6e2758c8ee6f08d3eef51a615d5b5b8a516b",
+    "rustc-1.57.0-x86_64-unknown-freebsd": "ef9af581c88b5d52f3b91f8781fbea77426364ac035bb7cb274f41fa3bf60706",
+    "rustc-1.57.0-x86_64-unknown-linux-gnu": "92257646cd85b7c03520c838920851c879845ed8dfd2b339d2ebb4480ee4d4d3",
+    "rustc-1.57.0-x86_64-unknown-linux-musl": "49ff02cdc94bd8732c2969b06006773311c8e41c188a9cef627b37eefb0b73d7",
+    "rustc-1.58.0-aarch64-apple-darwin": "7b3291177d4f8a73c8e20185a04bbc88775fc85eeb271c19bc8f37fb5051ae0c",
+    "rustc-1.58.0-aarch64-unknown-linux-gnu": "34d8fdaec504efe6e9448ad5a118ac0e7ef3bd9a8f6c49ea68204f2f9a9dae4e",
+    "rustc-1.58.0-aarch64-unknown-linux-musl": "2c6ee3dfdd496a01f55f6b0ae683d3acdecbd42ee386c4000b336351e89b3cac",
+    "rustc-1.58.0-x86_64-apple-darwin": "3d3815385dda1c1d8617ee14b682ec3804307b0f5a0ac5604a7dc5efc783263f",
+    "rustc-1.58.0-x86_64-pc-windows-msvc": "2296e7bd3e4977917e1cfd021a618064e3bac955338193fba89e84705306aed9",
+    "rustc-1.58.0-x86_64-unknown-freebsd": "89969a81fd9c9cfb94e6554bf1a8884417b0d5dde5e7c45bd4e9b1887771f5d5",
+    "rustc-1.58.0-x86_64-unknown-linux-gnu": "94e3a5e6dca2ae2516d6496568b6791b9501ac500c3e5faf6f42baaead41d404",
+    "rustc-1.58.0-x86_64-unknown-linux-musl": "1134b85ce578ac017650d8e7c360d14a85a1d6185c164678f95440cac1f6786d",
+    "rustc-1.58.1-aarch64-apple-darwin": "cbcc922fa499131b4f9b0ff6c656792edd34452dc902552a0d0dfa8f4690b996",
+    "rustc-1.58.1-aarch64-unknown-linux-gnu": "ad97b6e3ed1e6701ceaa1bad7f2da391546d27b121d967b606bd48542f21c669",
+    "rustc-1.58.1-aarch64-unknown-linux-musl": "156c5909cb6c9b5d96662f2eec87edefcdf019783082745b9abaeb97d1d45307",
+    "rustc-1.58.1-x86_64-apple-darwin": "859ea96ca53ed6480333273ccd39c0f9a487d7f288a5fd2646c3907353402fce",
+    "rustc-1.58.1-x86_64-pc-windows-msvc": "31bc5359886854fccf16956a92c4205372df0ba1be19642879a0e9d6441a069c",
+    "rustc-1.58.1-x86_64-unknown-freebsd": "ccc043fbf337adda1dc66611f8b8eea3d2fd9e1cee9adc1a07d1a3c4c0b4711b",
+    "rustc-1.58.1-x86_64-unknown-linux-gnu": "1bab764b75bec5b83ec88f6cf7e6127f0bc5bf64307277d1f5ce8838a8b8a415",
+    "rustc-1.58.1-x86_64-unknown-linux-musl": "626cfaf717b3e05d2e20726ecbbd7026edf8a816de06ef0f499e5a27339c1310",
+    "rustc-1.59.0-aarch64-apple-darwin": "caac78491d8f0844bb9a512989a409c35ff681a131495e7ebfacb69ba006bbc1",
+    "rustc-1.59.0-aarch64-unknown-linux-gnu": "04d4add5530d247214ec8afd32f2c91d75b219035130b877e4769cebcd4174d8",
+    "rustc-1.59.0-aarch64-unknown-linux-musl": "a50567a08ec5a33bdb60b4a6c4572cb85c2e48429ed6d98a28580ca7ed82d8ed",
+    "rustc-1.59.0-x86_64-apple-darwin": "eb5b613800c75882bed9e3bb48c325aac0e5ce418ae2b19f51e4ccf7e4781e0b",
+    "rustc-1.59.0-x86_64-pc-windows-msvc": "e838ecdba060b4ad3d0becc08027c9598977db40ac1f4e5fa9231725110ea06b",
+    "rustc-1.59.0-x86_64-unknown-freebsd": "053fe53aa72e9400b3657049cb0352a26268bd5a81a2b09500ff2cb150c32767",
+    "rustc-1.59.0-x86_64-unknown-linux-gnu": "e7ed041c93b77a7d986aa198d28f63ab96493fdf164bd28c8785c5b31a9e62d9",
+    "rustc-1.59.0-x86_64-unknown-linux-musl": "34e7b33acbffd2012906249509a0d364692767a15a54d10e67122361703ee811",
+    "rustfmt-1.48.0-aarch64-unknown-linux-gnu": "28f7d1ef37c034033eb0e30a13e5f0ad5bbc506adb8a8a9c03adce2b0d4842d5",
+    "rustfmt-1.48.0-aarch64-unknown-linux-musl": "e6efa0fae347f97dca3b892565302d35b4cedfee7cb6e2b5fcdb2801074fe018",
+    "rustfmt-1.48.0-x86_64-apple-darwin": "cfe593a9446e7dfa52ded8a7cca174ba0c2d1cac6e865d04e0890282f25d22e2",
+    "rustfmt-1.48.0-x86_64-pc-windows-msvc": "96d779befe8bca88d3cb69723d401d290a4a637746e8cc119126cfe9d5c773ee",
+    "rustfmt-1.48.0-x86_64-unknown-freebsd": "ae84ca6d0841e6be0f140efd67693a1a50520e6610f26e5ee57a15b5a9947588",
+    "rustfmt-1.48.0-x86_64-unknown-linux-gnu": "12d185cfd6ce15e4df3590bf1b9b3233df75e7aa14b42a9269b4235347a14b2b",
+    "rustfmt-1.48.0-x86_64-unknown-linux-musl": "1a8674af3fbe9616426a02fa4115057e411e7dfcc0f7bb377ee27e3a3bec15f4",
+    "rustfmt-1.49.0-aarch64-apple-darwin": "4f03d2913ecff9b534bc6c2c7684d0884958a1c8f12668fea86c0aa4371231ae",
+    "rustfmt-1.49.0-aarch64-unknown-linux-gnu": "9ef9c477911b3718539defa18ef5838b6f479e646d82e410643e5e8cb21791dc",
+    "rustfmt-1.49.0-aarch64-unknown-linux-musl": "40dbcf80a23055cf2245a6bbf5e16c0fd0300076e279b8e29d66de8af1d5409a",
+    "rustfmt-1.49.0-x86_64-apple-darwin": "e505092d5525dca1012d57e9c9dfd048cbbe2890e02e1327c1a0af44cd3d7aa1",
+    "rustfmt-1.49.0-x86_64-pc-windows-msvc": "e094798983f77ef95e28db1c561915f992f3a190813162b33e2bc6942485a485",
+    "rustfmt-1.49.0-x86_64-unknown-freebsd": "ed7465ddcc654b32822e48a8e91cd58391c36210b332f054a9ab5c1e5733ae74",
+    "rustfmt-1.49.0-x86_64-unknown-linux-gnu": "a1b1a9c06b9958116c37e212c5e04d921f78967e9f9956f6249a16e033f67a03",
+    "rustfmt-1.49.0-x86_64-unknown-linux-musl": "cad26f7f7f9c67f32e03a07ad84f9dc9b7f755213cc0cc596d2971836bcc0cc1",
+    "rustfmt-1.50.0-aarch64-apple-darwin": "1dd932c23b3e70c1183dcb58c431ddd97df72c173b4e28d3a3b008132079a914",
+    "rustfmt-1.50.0-aarch64-unknown-linux-gnu": "0bddf9a1b55bcdae7cef3b37c56ba5816a2b2c932d57dbe7cfc73acce65f5aff",
+    "rustfmt-1.50.0-aarch64-unknown-linux-musl": "c885b27194ad8405d2c75ff134d81c5a51c24ffcab2ce5f3684e8de8b353f66b",
+    "rustfmt-1.50.0-x86_64-apple-darwin": "90108b9bf4b529d12096d7e7c3ef97e77d2304ea142cd0352d0b9814df80c7d2",
+    "rustfmt-1.50.0-x86_64-pc-windows-msvc": "4ee791749b1312091ecb66bee916b0f70fa71cfae1315de8d3351c6da913d5f2",
+    "rustfmt-1.50.0-x86_64-unknown-freebsd": "037c575d92f87ee372b2bfb3b802c8a86690133ee1c82a5a8402ef9e97780f77",
+    "rustfmt-1.50.0-x86_64-unknown-linux-gnu": "2537e788067e56f263ab52869a6efbbf6be9f57ad6b14fc33ddab7cff79a3768",
+    "rustfmt-1.50.0-x86_64-unknown-linux-musl": "6f412c518e078f8891578b174d884cddf992b5fb72b14952f71d5ee8c2a743d8",
+    "rustfmt-1.51.0-aarch64-apple-darwin": "2f6966b51abc33a76b497776f061d049dc9c928aa09ea773a3404396002b33d8",
+    "rustfmt-1.51.0-aarch64-unknown-linux-gnu": "5dfa947dfc221ecb282a082263d79c5faf0c586acfcf7e416357d3e5107675c8",
+    "rustfmt-1.51.0-aarch64-unknown-linux-musl": "0fbca6b470e8c888b03adb501d45db68a5c19dcc05b8f5a1d73d5f9a4d1b3c01",
+    "rustfmt-1.51.0-x86_64-apple-darwin": "b30448ce429f2920b5a4d1bf50b40f4d251188f29ffaa6af12bfb131d993c5e0",
+    "rustfmt-1.51.0-x86_64-pc-windows-msvc": "520e8eaa186acc4f978fd30a34566b11073ed3396628e3dc192aa2862be42edd",
+    "rustfmt-1.51.0-x86_64-unknown-freebsd": "3693bd333303984ce0854452c31b5720cf6d8fa02f69062dc28b7db3b677bec2",
+    "rustfmt-1.51.0-x86_64-unknown-linux-gnu": "e50c03cbf104de7788eed8d5d923b5dc7555f12a3c045275751633121ce74d43",
+    "rustfmt-1.51.0-x86_64-unknown-linux-musl": "6798ff8f805cf1ddc187c4567fa7f3e32b9f347477b0956869caf1f31a99c374",
+    "rustfmt-1.52.0-aarch64-apple-darwin": "263296e44decd784b468de22519f7a22fa3dce3358bd96aab627f60b1f9778db",
+    "rustfmt-1.52.0-aarch64-unknown-linux-gnu": "f70260c7f6e39e20b376389d75e8c3518608860a3ce7647abeff626204341ea7",
+    "rustfmt-1.52.0-aarch64-unknown-linux-musl": "97190a6c8b6044c0fb375c71d672204adcf62d1b6c5d747715cc94a0ae631e04",
+    "rustfmt-1.52.0-x86_64-apple-darwin": "c3841b8568c00068ce6d264688320466c95307971a64adbb2b6ca6d5e54e158f",
+    "rustfmt-1.52.0-x86_64-pc-windows-msvc": "eba78266b8a381c2fbb07c4b3a1571a6fc102e1b9fc298ae362ab8da0aca41e5",
+    "rustfmt-1.52.0-x86_64-unknown-freebsd": "e150cd81ac2e7036ed9ff55b93c62cbcbd6fa2025371fda568a32a071cf94020",
+    "rustfmt-1.52.0-x86_64-unknown-linux-gnu": "7563b04b2900e9bef6360fb445baf00a8584072142d4554eb54f8109ac7486c5",
+    "rustfmt-1.52.0-x86_64-unknown-linux-musl": "ba74b93b4a70a7070d516a332a589b10bd161ab8b36826052ffa0569b1d6b5e6",
+    "rustfmt-1.52.1-aarch64-apple-darwin": "b02cf93d230a4147f2551e012b314b93d2d448ebc4ee71896918c488d8e6e446",
+    "rustfmt-1.52.1-aarch64-unknown-linux-gnu": "727d227f5e1e0ab3bcaa4f4adfe6b5e21fb70279b4d5825cb95fc6983c3cd9ae",
+    "rustfmt-1.52.1-aarch64-unknown-linux-musl": "f707919fb5ad7d0db02fd2e63293153b20043c4511385840835d6a8ae7087d96",
+    "rustfmt-1.52.1-x86_64-apple-darwin": "fc2d3cfd2742800745a97a3cb69a005166992c756dc9fd191add1f37842210e4",
+    "rustfmt-1.52.1-x86_64-pc-windows-msvc": "d5cf3e6be769dd266e66e0351062ff1317b537bf0f4e95def2a8f518f6e6571b",
+    "rustfmt-1.52.1-x86_64-unknown-freebsd": "ecfebd807b2addc80d102f4909f42c71104039e1f7d9b7bd7e6ebdb5072d8d6f",
+    "rustfmt-1.52.1-x86_64-unknown-linux-gnu": "1717c5eeae799b0ceee7f8b7180543713d08ad72e03af77b05dd1e69e32b06bc",
+    "rustfmt-1.52.1-x86_64-unknown-linux-musl": "5b19c462dc70b632e44189c1384aa753bdc20f9a9ad66d35dd34d321cfb19b1c",
+    "rustfmt-1.53.0-aarch64-apple-darwin": "4a29c3663a2c0f5133ca21e1c12223e9ef4fa3f8b1f29b98709ad588aa52c140",
+    "rustfmt-1.53.0-aarch64-unknown-linux-gnu": "d5157ddaf978a3619292a5b133390eea3a049b7903eeef25ded9f24c995a7c58",
+    "rustfmt-1.53.0-aarch64-unknown-linux-musl": "91006e773898a40af2f0e843e7f1111ce07320f1507e61d8c9a4ae216dfe245b",
+    "rustfmt-1.53.0-x86_64-apple-darwin": "b4db708e078615e1d21ad13acfc4b5943b3548d094d397c3b14e24dda3bd78ca",
+    "rustfmt-1.53.0-x86_64-pc-windows-msvc": "adead783882f055129268f11d137857bdcac5eb1ccc20ea8ff8edbb67026f6ff",
+    "rustfmt-1.53.0-x86_64-unknown-freebsd": "569c6185ad0868f855b1414a51f9e9eba52a0cbf270c0b674bcb4580eece668b",
+    "rustfmt-1.53.0-x86_64-unknown-linux-gnu": "e4e826c678f16c6a896e1226309c12c3677ff9c4bc8065ac6932fc616bb67572",
+    "rustfmt-1.53.0-x86_64-unknown-linux-musl": "6d2778b35149971308717e6f10c29f189f46003a1bb9490d495906c0ae6aad45",
+    "rustfmt-1.54.0-aarch64-apple-darwin": "1823b397d89bc23b1a8ec4df113c5f765a0e91cae655dc59fbf13be4616c0f3f",
+    "rustfmt-1.54.0-aarch64-unknown-linux-gnu": "82f45f13c8885663461f27ca7d590c341e41cdf2ea76f40d23b90d38d374cb46",
+    "rustfmt-1.54.0-aarch64-unknown-linux-musl": "fbdfde8d13d08718364a5dfd97f8b99898134a630a4ec13fe8405402688f746d",
+    "rustfmt-1.54.0-x86_64-apple-darwin": "e33122e00fa2ba319e229f3a92380e31b2b813398f3a681d0e1b2e6fbe3f135e",
+    "rustfmt-1.54.0-x86_64-pc-windows-msvc": "608da9f9cc59d24c14897febeb0983d0ace04264d91e3ff9dd8b57bb546a2965",
+    "rustfmt-1.54.0-x86_64-unknown-freebsd": "4b5098c749c547516ca2c81aabf87617d589ae674cdc48d7636b37cc5017d29b",
+    "rustfmt-1.54.0-x86_64-unknown-linux-gnu": "0205d6af87d381b93aa69bc75c0bd44ac5eb006832f0f505a851dc8d22aaf101",
+    "rustfmt-1.54.0-x86_64-unknown-linux-musl": "34a2321d2f7f57398b6f588f2e219639f0958d444ca283ff0c8d0144d8c09fc1",
+    "rustfmt-1.55.0-aarch64-apple-darwin": "dad1bcea851e509f289178c7bbd8fca5152efd1876450e353cc77fe5fccd2f46",
+    "rustfmt-1.55.0-aarch64-unknown-linux-gnu": "a0a24a0e5618997218cced0632dfe776315225ee394e8412ef5dcf9e21325b9c",
+    "rustfmt-1.55.0-aarch64-unknown-linux-musl": "736208df67d87b3ced05764d52de07470f44502c901c48ab6cc6dfe3cab6046f",
+    "rustfmt-1.55.0-x86_64-apple-darwin": "b38a096a59ecc6309bcbea67ed4e50de6d48cdc124ff5b721bf7e929ef4c4fa7",
+    "rustfmt-1.55.0-x86_64-pc-windows-msvc": "49f58043700b33578963faa22dcb993b5d604d7d8cc852ff53f11138f9a20f35",
+    "rustfmt-1.55.0-x86_64-unknown-freebsd": "5317af05afbcfde0fae7ba4ad5404901b0c611d826c7dd38926a8b08ade53c72",
+    "rustfmt-1.55.0-x86_64-unknown-linux-gnu": "ecb58add71d3f3cf8a213fe7b531bc230f8da5cecd835cee6429e76798b548cc",
+    "rustfmt-1.55.0-x86_64-unknown-linux-musl": "33bd862bbc9b54745c3e1d400440996fd0e6759c4d482f1a888ba8fafab29c3a",
+    "rustfmt-1.56.0-aarch64-apple-darwin": "0c1dcc80d2028748c38a4c3360048940a887ca899af577e9f3026c3d1a359469",
+    "rustfmt-1.56.0-aarch64-unknown-linux-gnu": "3dabc693866f74a956b99f8cac1f1beca6dbc38de6cc095ccdacbdccc18b4350",
+    "rustfmt-1.56.0-aarch64-unknown-linux-musl": "9d1b9405dc2cbeb7ff7f2ecb468a42d7a36429e642714de1605eb242947afc88",
+    "rustfmt-1.56.0-x86_64-apple-darwin": "f8fc28492af2fece8915db0959bb5af354706d63556854f4c149e6dbc9f3c11b",
+    "rustfmt-1.56.0-x86_64-pc-windows-msvc": "1080a5e5f3957eed2799ce65adf93b8bd8c0a9233c5149d8992c339fe7acab31",
+    "rustfmt-1.56.0-x86_64-unknown-freebsd": "a5e58bbf9407ac7da18df4d385f0988d299b1a71d18ce39fb7d1de15c007f5a6",
+    "rustfmt-1.56.0-x86_64-unknown-linux-gnu": "ce14465427e5919e407af9e58fea0a638aa02515f182a1a1c0b740cbd52a5e5a",
+    "rustfmt-1.56.0-x86_64-unknown-linux-musl": "98dbc11edb80de0c1303823f890434406c36501d89ee45ba2137d4ef4220db8a",
+    "rustfmt-1.56.1-aarch64-apple-darwin": "25e64095594e6aa4c25b2dfb8830108ba32af2917c1b1a4a1a966114d85199d2",
+    "rustfmt-1.56.1-aarch64-unknown-linux-gnu": "b6d1479d66c16eabcd708246521539a60eee31b1b3b492c20676ebbbcbca23fd",
+    "rustfmt-1.56.1-aarch64-unknown-linux-musl": "441f9df760f65a79ce15d79938cf984961cb712639d85e91765abadfc616002f",
+    "rustfmt-1.56.1-x86_64-apple-darwin": "fa4e086107b5219228cdd928fd4671f5ab7a1165c39ca79874fd99a0f865b12b",
+    "rustfmt-1.56.1-x86_64-pc-windows-msvc": "a18c253e6d29ea8575e9b25a1fe43c913082c0036e2532f372e376b8d0c0e15a",
+    "rustfmt-1.56.1-x86_64-unknown-freebsd": "b3f184b3cbe2139407e977838e98a843d90409cdebe86d64338841fb919281c9",
+    "rustfmt-1.56.1-x86_64-unknown-linux-gnu": "6dce6eced612048180892fa9016a06a901c9fc275da046d8e229986f4dd97115",
+    "rustfmt-1.56.1-x86_64-unknown-linux-musl": "0a307bd9a4b08a91f1fee0e90e412d92c9b55b75084c2e9b24ed99dd9469f4fb",
+    "rustfmt-1.57.0-aarch64-apple-darwin": "85fc5eedb0bb4d6ac599e567ae84debc05a3a5d2c162f73c59df5bf0d5d3fb19",
+    "rustfmt-1.57.0-aarch64-unknown-linux-gnu": "f8f4c4c16a24aaf4e0b9752395bf8b20154832ef6d0b9e98687de44b699ff5ff",
+    "rustfmt-1.57.0-aarch64-unknown-linux-musl": "093bda1fc0c087dffbdddafb9a2fe9f67e49cfc7794aaca22a92aab5d0f0c789",
+    "rustfmt-1.57.0-x86_64-apple-darwin": "83a928a03d484121531852a591b76a13c631e275ef376d57b9b23cf6e855f6b1",
+    "rustfmt-1.57.0-x86_64-pc-windows-msvc": "7c61a46df59d6c9386a5647df54a1a725d81dc924fb24fa7f7e1b51ad7ced047",
+    "rustfmt-1.57.0-x86_64-unknown-freebsd": "0d0bd640445e1e45a93ca0d0f5b0f03c464f6a91c9b5353c3ac136ba366bbf36",
+    "rustfmt-1.57.0-x86_64-unknown-linux-gnu": "48b09dbf1c7fc16e31123e8c83eede18c3577811762f574a5b24a2f759a172bb",
+    "rustfmt-1.57.0-x86_64-unknown-linux-musl": "6ed302cafc1363c8ba0bb789467a80be8558b3ed712331a0da2477f8d53f0794",
+    "rustfmt-1.58.0-aarch64-apple-darwin": "79f391f725e598163407df09570c3c2bfffc89250a08b3143c7f72db8ec0c632",
+    "rustfmt-1.58.0-aarch64-unknown-linux-gnu": "ddb03ea92c4274b2eccb43d0f25bb6ccd8beab53123715c3c51de7220b60b21e",
+    "rustfmt-1.58.0-aarch64-unknown-linux-musl": "8749c82a655e2f99bfc7b8c3d1f12c384edb8cee7b26078a7ddf87da57a31429",
+    "rustfmt-1.58.0-x86_64-apple-darwin": "83fb3514eec03049daadb2623f27b92d029b292c0ed6102c06f1a4a39f81b1f8",
+    "rustfmt-1.58.0-x86_64-pc-windows-msvc": "661a53930cfd8b74f9a66df0871a0bd8534829d845d5253292f7f223d17f0aa8",
+    "rustfmt-1.58.0-x86_64-unknown-freebsd": "a91b4561ca1cb756da40e17a2d270c464bb177289c2cc8352e2b5fcd26c0c63a",
+    "rustfmt-1.58.0-x86_64-unknown-linux-gnu": "4c4f0972406bf4a0a83be4cf2ee0a3556db1aa6aefedab4851ed19a3dd2e88bc",
+    "rustfmt-1.58.0-x86_64-unknown-linux-musl": "7075b11ab68bbdebce0884e42432d7599680fe023ea2ab4e81c2629d25fd32e7",
+    "rustfmt-1.58.1-aarch64-apple-darwin": "ede8f0bb46047e3e106b20bdd4e181fc81f810eed26d5f1816b0b0b4a9a5458a",
+    "rustfmt-1.58.1-aarch64-unknown-linux-gnu": "71dec8f396d87ec57e353000331e62c7ab0e431e26c42644d43d78fd8d6df3f5",
+    "rustfmt-1.58.1-aarch64-unknown-linux-musl": "f605d5cf81369a51cacb6ce17d57dd553096b6843c249c37f996d0c768476429",
+    "rustfmt-1.58.1-x86_64-apple-darwin": "6ec7ef5c492531714f42936f7e03ffa9b428953692c64575b45da1dfaa3905b4",
+    "rustfmt-1.58.1-x86_64-pc-windows-msvc": "c2d30d3791e612f2f2a6e9eef52707ce79e7bf2ff5c6150bdf91039686988eda",
+    "rustfmt-1.58.1-x86_64-unknown-freebsd": "d2a32f7479dcb5bb71ec8151912cfa315bfaeb7c3b45ad10afcb6bb7b9652d75",
+    "rustfmt-1.58.1-x86_64-unknown-linux-gnu": "09328241bd46a21793a5a76ba6a1a5b862c6bfa29afdabdc9c889b08c81ee8ba",
+    "rustfmt-1.58.1-x86_64-unknown-linux-musl": "8189d38bdd1225241ecbd75b0869c1945450a5c28b675713892ae32cf0b77750",
+    "rustfmt-1.59.0-aarch64-apple-darwin": "70a677515845f9b22b464d022958a2d0ba7c927a4979f3631b1f851ea2e9b2a8",
+    "rustfmt-1.59.0-aarch64-unknown-linux-gnu": "e79b98a6bb51ed225436375fd095610b88093f287404836949d394a5d315e834",
+    "rustfmt-1.59.0-aarch64-unknown-linux-musl": "dc977d6459b1d4d9e761dc20a60f1f734e6081b1b17670eb4bbe9d2fc292b9de",
+    "rustfmt-1.59.0-x86_64-apple-darwin": "52d5579999e146e999426d57be78a8b26ace6ab7810aefb968f69e6b2c9ecf53",
+    "rustfmt-1.59.0-x86_64-pc-windows-msvc": "cd923eae91c5652fa983abbc07ceb67d6f5b8f98664f86cfc1bff7ec1374e0c1",
+    "rustfmt-1.59.0-x86_64-unknown-freebsd": "026abe662bf0ca734796e93224bed7ad9015a3e2613ca7db59c9b89e3d6088bb",
+    "rustfmt-1.59.0-x86_64-unknown-linux-gnu": "2932efec54b152e094e557c351aa5844b87e61bbcb4d4b7bf0a2dd7ad457df39",
+    "rustfmt-1.59.0-x86_64-unknown-linux-musl": "868aebea8792baa964b5300e6c34b5006660abd4d7aeb93f2d7104de1cfad134",
+}
diff --git a/third_party/rules_rust/rust/platform/BUILD.bazel b/third_party/rules_rust/rust/platform/BUILD.bazel
new file mode 100644
index 0000000..459b9fb
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/BUILD.bazel
@@ -0,0 +1,26 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load(":platform.bzl", "declare_config_settings")
+
+package(default_visibility = ["//visibility:public"])
+
+declare_config_settings()
+
+package_group(
+    name = "function_transition_allowlist",
+    packages = [
+        "//...",
+    ],
+)
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+    visibility = ["//rust:__subpackages__"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//platform:bzl_lib` target instead",
+    visibility = ["//rust:__subpackages__"],
+)
diff --git a/third_party/rules_rust/rust/platform/channel/BUILD.bazel b/third_party/rules_rust/rust/platform/channel/BUILD.bazel
new file mode 100644
index 0000000..84fc8c7
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/channel/BUILD.bazel
@@ -0,0 +1,22 @@
+package(default_visibility = ["//visibility:public"])
+
+# Allows toolchains and targets to constrain themselves based on Rust release
+# channels, for example when depending on features only available in Nightly.
+#
+# https://doc.rust-lang.org/book/appendix-07-nightly-rust.html
+constraint_setting(name = "channel")
+
+constraint_value(
+    name = "beta",
+    constraint_setting = ":channel",
+)
+
+constraint_value(
+    name = "nightly",
+    constraint_setting = ":channel",
+)
+
+constraint_value(
+    name = "stable",
+    constraint_setting = ":channel",
+)
diff --git a/third_party/rules_rust/rust/platform/cpu/BUILD.bazel b/third_party/rules_rust/rust/platform/cpu/BUILD.bazel
new file mode 100644
index 0000000..476f8cf
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/cpu/BUILD.bazel
@@ -0,0 +1,5 @@
+constraint_value(
+    name = "wasm32",
+    constraint_setting = "@platforms//cpu",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/rust/platform/os/BUILD.bazel b/third_party/rules_rust/rust/platform/os/BUILD.bazel
new file mode 100644
index 0000000..7692abe
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/os/BUILD.bazel
@@ -0,0 +1,11 @@
+constraint_value(
+    name = "unknown",
+    constraint_setting = "@platforms//os",
+    visibility = ["//visibility:public"],
+)
+
+constraint_value(
+    name = "wasi",
+    constraint_setting = "@platforms//os",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/rust/platform/platform.bzl b/third_party/rules_rust/rust/platform/platform.bzl
new file mode 100644
index 0000000..de02a89
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/platform.bzl
@@ -0,0 +1,90 @@
+"""Definitions for support config settings and platform definitions"""
+
+load("@bazel_skylib//lib:selects.bzl", "selects")
+load(
+    ":triple_mappings.bzl",
+    "SUPPORTED_PLATFORM_TRIPLES",
+    "cpu_arch_to_constraints",
+    "system_to_constraints",
+    "triple_to_constraint_set",
+)
+
+_SUPPORTED_CPU_ARCH = [
+    "aarch64",
+    "arm",
+    "armv7",
+    "i686",
+    "powerpc",
+    "s390x",
+    "x86_64",
+]
+
+_SUPPORTED_SYSTEMS = [
+    "android",
+    "darwin",
+    "freebsd",
+    "ios",
+    "linux",
+    "windows",
+]
+
+# buildifier: disable=unnamed-macro
+def declare_config_settings():
+    """Helper function for declaring `config_setting`s"""
+    for cpu_arch in _SUPPORTED_CPU_ARCH:
+        native.config_setting(
+            name = cpu_arch,
+            constraint_values = cpu_arch_to_constraints(cpu_arch),
+        )
+
+    for system in _SUPPORTED_SYSTEMS:
+        native.config_setting(
+            name = system,
+            constraint_values = system_to_constraints(system),
+        )
+
+    # Add alias for OSX to "darwin" to match what users will be expecting.
+    native.alias(
+        name = "osx",
+        actual = ":darwin",
+    )
+
+    # Add alias for OSX to "macos" to be consistent with the long-term
+    # direction of `@platforms` in using the OS's modern name.
+    native.alias(
+        name = "macos",
+        actual = ":darwin",
+    )
+
+    all_supported_triples = SUPPORTED_PLATFORM_TRIPLES
+    for triple in all_supported_triples:
+        native.config_setting(
+            name = triple,
+            constraint_values = triple_to_constraint_set(triple),
+        )
+
+    native.platform(
+        name = "wasm",
+        constraint_values = [
+            str(Label("//rust/platform/cpu:wasm32")),
+            str(Label("//rust/platform/os:unknown")),
+        ],
+    )
+
+    native.platform(
+        name = "wasi",
+        constraint_values = [
+            str(Label("//rust/platform/cpu:wasm32")),
+            str(Label("//rust/platform/os:wasi")),
+        ],
+    )
+
+    selects.config_setting_group(
+        name = "unix",
+        match_any = [
+            ":android",
+            ":darwin",
+            ":freebsd",
+            ":linux",
+        ],
+    )
diff --git a/third_party/rules_rust/rust/platform/triple.bzl b/third_party/rules_rust/rust/platform/triple.bzl
new file mode 100644
index 0000000..13a59a4
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/triple.bzl
@@ -0,0 +1,54 @@
+"""Triples are a way to define information about a platform/system. This module provides
+a way to convert a triple string into a well structured object to avoid constant string
+parsing in starlark code.
+
+Triples can be described at the following link: 
+https://clang.llvm.org/docs/CrossCompilation.html#target-triple
+"""
+
+def triple(triple):
+    """Constructs a struct containing each component of the provided triple
+
+    Args:
+        triple (str): A platform triple. eg: `x86_64-unknown-linux-gnu`
+
+    Returns:
+        struct:
+            - arch (str): The triple's CPU architecture
+            - vendor (str): The vendor of the system
+            - system (str): The name of the system
+            - abi (str, optional): The abi to use or None if abi does not apply.
+            - triple (str): The original triple
+    """
+    if triple == "wasm32-wasi":
+        return struct(
+            arch = "wasm32",
+            system = "wasi",
+            vendor = "wasi",
+            abi = None,
+            triple = triple,
+        )
+
+    component_parts = triple.split("-")
+    if len(component_parts) < 3:
+        fail("Expected target triple to contain at least three sections separated by '-'")
+
+    cpu_arch = component_parts[0]
+    vendor = component_parts[1]
+    system = component_parts[2]
+    abi = None
+
+    if system == "androideabi":
+        system = "android"
+        abi = "eabi"
+
+    if len(component_parts) == 4:
+        abi = component_parts[3]
+
+    return struct(
+        arch = cpu_arch,
+        vendor = vendor,
+        system = system,
+        abi = abi,
+        triple = triple,
+    )
diff --git a/third_party/rules_rust/rust/platform/triple_mappings.bzl b/third_party/rules_rust/rust/platform/triple_mappings.bzl
new file mode 100644
index 0000000..644f973
--- /dev/null
+++ b/third_party/rules_rust/rust/platform/triple_mappings.bzl
@@ -0,0 +1,282 @@
+"""Helpers for constructing supported Rust platform triples"""
+
+load("//rust/platform:triple.bzl", "triple")
+
+# All T1 Platforms should be supported, but aren't, see inline notes.
+SUPPORTED_T1_PLATFORM_TRIPLES = [
+    "i686-apple-darwin",
+    "i686-pc-windows-msvc",
+    "i686-unknown-linux-gnu",
+    "x86_64-apple-darwin",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    # N.B. These "alternative" envs are not supported, as bazel cannot distinguish between them
+    # and others using existing @platforms// config_values
+    #
+    #"i686-pc-windows-gnu",
+    #"x86_64-pc-windows-gnu",
+]
+
+# Some T2 Platforms are supported, provided we have mappings to @platforms// entries.
+# See @rules_rust//rust/platform:triple_mappings.bzl for the complete list.
+SUPPORTED_T2_PLATFORM_TRIPLES = [
+    "aarch64-apple-darwin",
+    "aarch64-apple-ios",
+    "aarch64-linux-android",
+    "aarch64-unknown-linux-gnu",
+    "arm-unknown-linux-gnueabi",
+    "armv7-unknown-linux-gnueabi",
+    "arm-unknown-linux-gnueabihf",
+    "armv7-unknown-linux-gnueabihf",
+    "i686-linux-android",
+    "i686-unknown-freebsd",
+    "powerpc-unknown-linux-gnu",
+    "s390x-unknown-linux-gnu",
+    "wasm32-unknown-unknown",
+    "wasm32-wasi",
+    "x86_64-apple-ios",
+    "x86_64-linux-android",
+    "x86_64-unknown-freebsd",
+]
+
+SUPPORTED_PLATFORM_TRIPLES = SUPPORTED_T1_PLATFORM_TRIPLES + SUPPORTED_T2_PLATFORM_TRIPLES
+
+# CPUs that map to a "@platforms//cpu entry
+_CPU_ARCH_TO_BUILTIN_PLAT_SUFFIX = {
+    "aarch64": "aarch64",
+    "arm": "arm",
+    "armv7": "armv7",
+    "armv7s": None,
+    "asmjs": None,
+    "i386": "i386",
+    "i586": None,
+    "i686": "x86_32",
+    "le32": None,
+    "mips": None,
+    "mipsel": None,
+    "powerpc": "ppc",
+    "powerpc64": None,
+    "powerpc64le": None,
+    "s390": None,
+    "s390x": "s390x",
+    "thumbv7m": "armv7",
+    "wasm32": None,
+    "x86_64": "x86_64",
+}
+
+# Systems that map to a "@platforms//os entry
+_SYSTEM_TO_BUILTIN_SYS_SUFFIX = {
+    "android": "android",
+    "bitrig": None,
+    "darwin": "osx",
+    "dragonfly": None,
+    "eabi": "none",
+    "emscripten": None,
+    "freebsd": "freebsd",
+    "ios": "ios",
+    "linux": "linux",
+    "nacl": None,
+    "netbsd": None,
+    "openbsd": "openbsd",
+    "solaris": None,
+    "unknown": None,
+    "wasi": None,
+    "windows": "windows",
+}
+
+_SYSTEM_TO_BINARY_EXT = {
+    "android": "",
+    "darwin": "",
+    "eabi": "",
+    "emscripten": ".js",
+    "freebsd": "",
+    "ios": "",
+    "linux": "",
+    # This is currently a hack allowing us to have the proper
+    # generated extension for the wasm target, similarly to the
+    # windows target
+    "unknown": ".wasm",
+    "wasi": ".wasm",
+    "windows": ".exe",
+}
+
+_SYSTEM_TO_STATICLIB_EXT = {
+    "android": ".a",
+    "darwin": ".a",
+    "eabi": ".a",
+    "emscripten": ".js",
+    "freebsd": ".a",
+    "ios": ".a",
+    "linux": ".a",
+    "unknown": "",
+    "wasi": "",
+    "windows": ".lib",
+}
+
+_SYSTEM_TO_DYLIB_EXT = {
+    "android": ".so",
+    "darwin": ".dylib",
+    "eabi": ".so",
+    "emscripten": ".js",
+    "freebsd": ".so",
+    "ios": ".dylib",
+    "linux": ".so",
+    "unknown": ".wasm",
+    "wasi": ".wasm",
+    "windows": ".dll",
+}
+
+# See https://github.com/rust-lang/rust/blob/master/src/libstd/build.rs
+_SYSTEM_TO_STDLIB_LINKFLAGS = {
+    # NOTE: Rust stdlib `build.rs` treats android as a subset of linux, rust rules treat android
+    # as its own system.
+    "android": ["-ldl", "-llog", "-lgcc"],
+    "bitrig": [],
+    # TODO(gregbowyer): If rust stdlib is compiled for cloudabi with the backtrace feature it
+    # includes `-lunwind` but this might not actually be required.
+    # I am not sure which is the common configuration or how we encode it as a link flag.
+    "cloudabi": ["-lunwind", "-lc", "-lcompiler_rt"],
+    "darwin": ["-lSystem", "-lresolv"],
+    "dragonfly": ["-lpthread"],
+    "eabi": [],
+    "emscripten": [],
+    # TODO(bazelbuild/rules_cc#75):
+    #
+    # Right now bazel cc rules does not specify the exact flag setup needed for calling out system
+    # libs, that is we dont know given a toolchain if it should be, for example,
+    # `-lxxx` or `/Lxxx` or `xxx.lib` etc.
+    #
+    # We include the flag setup as they are _commonly seen_ on various platforms with a cc_rules
+    # style override for people doing things like gnu-mingw on windows.
+    #
+    # If you are reading this ... sorry! set the env var `BAZEL_RUST_STDLIB_LINKFLAGS` to
+    # what you need for your specific setup, for example like so
+    # `BAZEL_RUST_STDLIB_LINKFLAGS="-ladvapi32:-lws2_32:-luserenv"`
+    "freebsd": ["-lexecinfo", "-lpthread"],
+    "fuchsia": ["-lzircon", "-lfdio"],
+    "illumos": ["-lsocket", "-lposix4", "-lpthread", "-lresolv", "-lnsl", "-lumem"],
+    "ios": ["-lSystem", "-lobjc", "-framework Security", "-framework Foundation", "-lresolv"],
+    # TODO: This ignores musl. Longer term what does Bazel think about musl?
+    "linux": ["-ldl", "-lpthread"],
+    "nacl": [],
+    "netbsd": ["-lpthread", "-lrt"],
+    "openbsd": ["-lpthread"],
+    "solaris": ["-lsocket", "-lposix4", "-lpthread", "-lresolv"],
+    "unknown": [],
+    "uwp": ["ws2_32.lib"],
+    "wasi": [],
+    "windows": ["advapi32.lib", "ws2_32.lib", "userenv.lib"],
+}
+
+def cpu_arch_to_constraints(cpu_arch):
+    plat_suffix = _CPU_ARCH_TO_BUILTIN_PLAT_SUFFIX[cpu_arch]
+
+    if not plat_suffix:
+        fail("CPU architecture \"{}\" is not supported by rules_rust".format(cpu_arch))
+
+    return ["@platforms//cpu:{}".format(plat_suffix)]
+
+def vendor_to_constraints(_vendor):
+    # TODO(acmcarther): Review:
+    #
+    # My current understanding is that vendors can't have a material impact on
+    # constraint sets.
+    return []
+
+def system_to_constraints(system):
+    sys_suffix = _SYSTEM_TO_BUILTIN_SYS_SUFFIX[system]
+
+    if not sys_suffix:
+        fail("System \"{}\" is not supported by rules_rust".format(sys_suffix))
+
+    return ["@platforms//os:{}".format(sys_suffix)]
+
+def abi_to_constraints(abi):
+    # iOS simulator
+    if abi == "sim":
+        return ["@build_bazel_apple_support//constraints:simulator"]
+    else:
+        # TODO(acmcarther): Implement when C++ toolchain is more mature and we
+        # figure out how they're doing this
+        return []
+
+def triple_to_system(target_triple):
+    """Returns a system name for a given platform triple
+
+    **Deprecated**: Use triple() from triple.bzl directly.
+
+    Args:
+        target_triple (str): A platform triple. eg: `x86_64-unknown-linux-gnu`
+
+    Returns:
+        str: A system name
+    """
+    return triple(target_triple).system
+
+def triple_to_arch(target_triple):
+    """Returns a system architecture name for a given platform triple
+
+    **Deprecated**: Use triple() from triple.bzl directly.
+
+    Args:
+        target_triple (str): A platform triple. eg: `x86_64-unknown-linux-gnu`
+
+    Returns:
+        str: A cpu architecture
+    """
+    return triple(target_triple).arch
+
+def triple_to_abi(target_triple):
+    """Returns a system abi name for a given platform triple
+
+    **Deprecated**: Use triple() from triple.bzl directly.
+
+    Args:
+        target_triple (str): A platform triple. eg: `x86_64-unknown-linux-gnu`
+
+    Returns:
+        str: The triple's abi
+    """
+    return triple(target_triple).system
+
+def system_to_dylib_ext(system):
+    return _SYSTEM_TO_DYLIB_EXT[system]
+
+def system_to_staticlib_ext(system):
+    return _SYSTEM_TO_STATICLIB_EXT[system]
+
+def system_to_binary_ext(system):
+    return _SYSTEM_TO_BINARY_EXT[system]
+
+def system_to_stdlib_linkflags(system):
+    return _SYSTEM_TO_STDLIB_LINKFLAGS[system]
+
+def triple_to_constraint_set(target_triple):
+    """Returns a set of constraints for a given platform triple
+
+    Args:
+        target_triple (str): A platform triple. eg: `x86_64-unknown-linux-gnu`
+
+    Returns:
+        list: A list of constraints (each represented by a list of strings)
+    """
+    if target_triple == "wasm32-wasi":
+        return [
+            "@rules_rust//rust/platform/cpu:wasm32",
+            "@rules_rust//rust/platform/os:wasi",
+        ]
+    if target_triple == "wasm32-unknown-unknown":
+        return [
+            "@rules_rust//rust/platform/cpu:wasm32",
+            "@rules_rust//rust/platform/os:unknown",
+        ]
+
+    triple_struct = triple(target_triple)
+
+    constraint_set = []
+    constraint_set += cpu_arch_to_constraints(triple_struct.arch)
+    constraint_set += vendor_to_constraints(triple_struct.vendor)
+    constraint_set += system_to_constraints(triple_struct.system)
+    constraint_set += abi_to_constraints(triple_struct.abi)
+
+    return constraint_set
diff --git a/third_party/rules_rust/rust/private/BUILD.bazel b/third_party/rules_rust/rust/private/BUILD.bazel
new file mode 100644
index 0000000..929a39e
--- /dev/null
+++ b/third_party/rules_rust/rust/private/BUILD.bazel
@@ -0,0 +1,24 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//rust/private:rust_analyzer.bzl", "rust_analyzer_detect_sysroot")
+load("//rust/private:stamp.bzl", "stamp_build_setting")
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+    visibility = ["//rust:__subpackages__"],
+    deps = ["//rust/platform:bzl_lib"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//private:bzl_lib` target instead",
+    visibility = ["//rust:__subpackages__"],
+)
+
+stamp_build_setting(name = "stamp")
+
+rust_analyzer_detect_sysroot(
+    name = "rust_analyzer_detect_sysroot",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/rust/private/README.md b/third_party/rules_rust/rust/private/README.md
new file mode 100644
index 0000000..a7a45c6
--- /dev/null
+++ b/third_party/rules_rust/rust/private/README.md
@@ -0,0 +1 @@
+Implementation details of the rules that are not publicly exposed.
\ No newline at end of file
diff --git a/third_party/rules_rust/rust/private/clippy.bzl b/third_party/rules_rust/rust/private/clippy.bzl
new file mode 100644
index 0000000..d1464e9
--- /dev/null
+++ b/third_party/rules_rust/rust/private/clippy.bzl
@@ -0,0 +1,304 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""A module defining clippy rules"""
+
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:providers.bzl", "CaptureClippyOutputInfo", "ClippyInfo")
+load(
+    "//rust/private:rustc.bzl",
+    "collect_deps",
+    "collect_inputs",
+    "construct_arguments",
+)
+load(
+    "//rust/private:utils.bzl",
+    "determine_output_hash",
+    "find_cc_toolchain",
+    "find_toolchain",
+)
+
+def _get_clippy_ready_crate_info(target, aspect_ctx):
+    """Check that a target is suitable for clippy and extract the `CrateInfo` provider from it.
+
+    Args:
+        target (Target): The target the aspect is running on.
+        aspect_ctx (ctx, optional): The aspect's context object.
+
+    Returns:
+        CrateInfo, optional: A `CrateInfo` provider if clippy should be run or `None`.
+    """
+
+    # Ignore external targets
+    if target.label.workspace_root.startswith("external"):
+        return None
+
+    # Targets annotated with `noclippy` will not be formatted
+    if aspect_ctx and "noclippy" in aspect_ctx.rule.attr.tags:
+        return None
+
+    # Obviously ignore any targets that don't contain `CrateInfo`
+    if rust_common.crate_info not in target:
+        return None
+
+    return target[rust_common.crate_info]
+
+def _clippy_aspect_impl(target, ctx):
+    crate_info = _get_clippy_ready_crate_info(target, ctx)
+    if not crate_info:
+        return [ClippyInfo(output = depset([]))]
+
+    toolchain = find_toolchain(ctx)
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+
+    dep_info, build_info, linkstamps = collect_deps(
+        deps = crate_info.deps,
+        proc_macro_deps = crate_info.proc_macro_deps,
+        aliases = crate_info.aliases,
+        # Clippy doesn't need to invoke transitive linking, therefore doesn't need linkstamps.
+        are_linkstamps_supported = False,
+    )
+
+    compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs = collect_inputs(
+        ctx,
+        ctx.rule.file,
+        ctx.rule.files,
+        linkstamps,
+        toolchain,
+        cc_toolchain,
+        feature_configuration,
+        crate_info,
+        dep_info,
+        build_info,
+    )
+
+    args, env = construct_arguments(
+        ctx = ctx,
+        attr = ctx.rule.attr,
+        file = ctx.file,
+        toolchain = toolchain,
+        tool_path = toolchain.clippy_driver.path,
+        cc_toolchain = cc_toolchain,
+        feature_configuration = feature_configuration,
+        crate_info = crate_info,
+        dep_info = dep_info,
+        linkstamp_outs = linkstamp_outs,
+        ambiguous_libs = ambiguous_libs,
+        output_hash = determine_output_hash(crate_info.root, ctx.label),
+        rust_flags = [],
+        out_dir = out_dir,
+        build_env_files = build_env_files,
+        build_flags_files = build_flags_files,
+        emit = ["dep-info", "metadata"],
+    )
+
+    if crate_info.is_test:
+        args.rustc_flags.add("--test")
+
+    # For remote execution purposes, the clippy_out file must be a sibling of crate_info.output
+    # or rustc may fail to create intermediate output files because the directory does not exist.
+    if ctx.attr._capture_output[CaptureClippyOutputInfo].capture_output:
+        clippy_out = ctx.actions.declare_file(ctx.label.name + ".clippy.out", sibling = crate_info.output)
+        args.process_wrapper_flags.add("--stderr-file", clippy_out.path)
+
+        # If we are capturing the output, we want the build system to be able to keep going
+        # and consume the output. Some clippy lints are denials, so we treat them as warnings.
+        args.rustc_flags.add("-Wclippy::all")
+    else:
+        # A marker file indicating clippy has executed successfully.
+        # This file is necessary because "ctx.actions.run" mandates an output.
+        clippy_out = ctx.actions.declare_file(ctx.label.name + ".clippy.ok", sibling = crate_info.output)
+        args.process_wrapper_flags.add("--touch-file", clippy_out.path)
+
+        # Turn any warnings from clippy or rustc into an error, as otherwise
+        # Bazel will consider the execution result of the aspect to be "success",
+        # and Clippy won't be re-triggered unless the source file is modified.
+        if "__bindgen" in ctx.rule.attr.tags:
+            # bindgen-generated content is likely to trigger warnings, so
+            # only fail on clippy warnings
+            args.rustc_flags.add("-Dclippy::style")
+            args.rustc_flags.add("-Dclippy::correctness")
+            args.rustc_flags.add("-Dclippy::complexity")
+            args.rustc_flags.add("-Dclippy::perf")
+        else:
+            # fail on any warning
+            args.rustc_flags.add("-Dwarnings")
+
+    # Upstream clippy requires one of these two filenames or it silently uses
+    # the default config. Enforce the naming so users are not confused.
+    valid_config_file_names = [".clippy.toml", "clippy.toml"]
+    if ctx.file._config.basename not in valid_config_file_names:
+        fail("The clippy config file must be named one of: {}".format(valid_config_file_names))
+    env["CLIPPY_CONF_DIR"] = "${{pwd}}/{}".format(ctx.file._config.dirname)
+    compile_inputs = depset([ctx.file._config], transitive = [compile_inputs])
+
+    ctx.actions.run(
+        executable = ctx.executable._process_wrapper,
+        inputs = compile_inputs,
+        outputs = [clippy_out],
+        env = env,
+        tools = [toolchain.clippy_driver],
+        arguments = args.all,
+        mnemonic = "Clippy",
+    )
+
+    return [
+        OutputGroupInfo(clippy_checks = depset([clippy_out])),
+        ClippyInfo(output = depset([clippy_out])),
+    ]
+
+# Example: Run the clippy checker on all targets in the codebase.
+#   bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect \
+#               --output_groups=clippy_checks \
+#               //...
+rust_clippy_aspect = aspect(
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    attrs = {
+        "_capture_output": attr.label(
+            doc = "Value of the `capture_clippy_output` build setting",
+            default = Label("//:capture_clippy_output"),
+        ),
+        "_cc_toolchain": attr.label(
+            doc = (
+                "Required attribute to access the cc_toolchain. See [Accessing the C++ toolchain]" +
+                "(https://docs.bazel.build/versions/master/integrating-with-rules-cc.html#accessing-the-c-toolchain)"
+            ),
+            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
+        ),
+        "_config": attr.label(
+            doc = "The `clippy.toml` file used for configuration",
+            allow_single_file = True,
+            default = Label("//:clippy.toml"),
+        ),
+        "_error_format": attr.label(
+            doc = "The desired `--error-format` flags for clippy",
+            default = "//:error_format",
+        ),
+        "_extra_rustc_flags": attr.label(default = "//:extra_rustc_flags"),
+        "_process_wrapper": attr.label(
+            doc = "A process wrapper for running clippy on all platforms",
+            default = Label("//util/process_wrapper"),
+            executable = True,
+            cfg = "exec",
+        ),
+    },
+    provides = [ClippyInfo],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    implementation = _clippy_aspect_impl,
+    doc = """\
+Executes the clippy checker on specified targets.
+
+This aspect applies to existing rust_library, rust_test, and rust_binary rules.
+
+As an example, if the following is defined in `examples/hello_lib/BUILD.bazel`:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Then the targets can be analyzed with clippy using the following command:
+
+```output
+$ bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect \
+              --output_groups=clippy_checks //hello_lib:all
+```
+""",
+)
+
+def _rust_clippy_rule_impl(ctx):
+    clippy_ready_targets = [dep for dep in ctx.attr.deps if "clippy_checks" in dir(dep[OutputGroupInfo])]
+    files = depset([], transitive = [dep[OutputGroupInfo].clippy_checks for dep in clippy_ready_targets])
+    return [DefaultInfo(files = files)]
+
+rust_clippy = rule(
+    implementation = _rust_clippy_rule_impl,
+    attrs = {
+        "deps": attr.label_list(
+            doc = "Rust targets to run clippy on.",
+            providers = [rust_common.crate_info],
+            aspects = [rust_clippy_aspect],
+        ),
+    },
+    doc = """\
+Executes the clippy checker on a specific target.
+
+Similar to `rust_clippy_aspect`, but allows specifying a list of dependencies \
+within the build system.
+
+For example, given the following example targets:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "hello_lib",
+    srcs = ["src/lib.rs"],
+)
+
+rust_test(
+    name = "greeting_test",
+    srcs = ["tests/greeting.rs"],
+    deps = [":hello_lib"],
+)
+```
+
+Rust clippy can be set as a build target with the following:
+
+```python
+load("@rules_rust//rust:defs.bzl", "rust_clippy")
+
+rust_clippy(
+    name = "hello_library_clippy",
+    testonly = True,
+    deps = [
+        ":hello_lib",
+        ":greeting_test",
+    ],
+)
+```
+""",
+)
+
+def _capture_clippy_output_impl(ctx):
+    """Implementation of the `capture_clippy_output` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list containing the CaptureClippyOutputInfo provider
+    """
+    return [CaptureClippyOutputInfo(capture_output = ctx.build_setting_value)]
+
+capture_clippy_output = rule(
+    doc = "Control whether to print clippy output or store it to a file, using the configured error_format.",
+    implementation = _capture_clippy_output_impl,
+    build_setting = config.bool(flag = True),
+)
diff --git a/third_party/rules_rust/rust/private/common.bzl b/third_party/rules_rust/rust/private/common.bzl
new file mode 100644
index 0000000..78a3011
--- /dev/null
+++ b/third_party/rules_rust/rust/private/common.bzl
@@ -0,0 +1,60 @@
+# Copyright 2021 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""A resilient API layer wrapping compilation and other logic for Rust rules.
+
+This module is meant to be used by custom rules that need to compile Rust code
+and cannot simply rely on writing a macro that wraps `rust_library`. This module
+provides the lower-level interface to Rust providers, actions, and functions.
+Do not load this file directly; instead, load the top-level `defs.bzl` file,
+which exports the `rust_common` struct.
+
+In the Bazel lingo, `rust_common` gives the access to the Rust Sandwich API.
+"""
+
+load(":providers.bzl", "CrateInfo", "DepInfo", "StdLibInfo")
+
+# These constants only represent the default value for attributes and macros
+# defiend in `rules_rust`. Like any attribute public attribute, they can be
+# overwritten by the user on the rules they're defiend on.
+#
+# Note: Code in `.github/workflows/crate_universe.yaml` looks for this line, if
+# you remove it or change its format, you will also need to update that code.
+DEFAULT_RUST_VERSION = "1.59.0"
+DEFAULT_RUST_EDITION = "2018"
+
+def _create_crate_info(**kwargs):
+    """A constructor for a `CrateInfo` provider
+
+    This function should be used in place of directly creating a `CrateInfo`
+    provider to improve API stability.
+
+    Args:
+        **kwargs: An inital set of keyword arguments.
+
+    Returns:
+        CrateInfo: A provider
+    """
+    if not "wrapped_crate_type" in kwargs:
+        kwargs.update({"wrapped_crate_type": None})
+    return CrateInfo(**kwargs)
+
+rust_common = struct(
+    create_crate_info = _create_crate_info,
+    crate_info = CrateInfo,
+    dep_info = DepInfo,
+    stdlib_info = StdLibInfo,
+    default_edition = DEFAULT_RUST_EDITION,
+    default_version = DEFAULT_RUST_VERSION,
+)
diff --git a/third_party/rules_rust/rust/private/dummy_cc_toolchain/BUILD.bazel b/third_party/rules_rust/rust/private/dummy_cc_toolchain/BUILD.bazel
new file mode 100644
index 0000000..004d233
--- /dev/null
+++ b/third_party/rules_rust/rust/private/dummy_cc_toolchain/BUILD.bazel
@@ -0,0 +1,13 @@
+load(":dummy_cc_toolchain.bzl", "dummy_cc_toolchain")
+
+dummy_cc_toolchain(name = "dummy_cc_wasm32")
+
+# When compiling Rust code for wasm32, we avoid linking to cpp code so we introduce a dummy cc
+# toolchain since we know we'll never look it up.
+# TODO(jedmonds@spotify.com): Need to support linking C code to rust code when compiling for wasm32.
+toolchain(
+    name = "dummy_cc_wasm32_toolchain",
+    target_compatible_with = ["//rust/platform/cpu:wasm32"],
+    toolchain = ":dummy_cc_wasm32",
+    toolchain_type = "@bazel_tools//tools/cpp:toolchain_type",
+)
diff --git a/third_party/rules_rust/rust/private/dummy_cc_toolchain/dummy_cc_toolchain.bzl b/third_party/rules_rust/rust/private/dummy_cc_toolchain/dummy_cc_toolchain.bzl
new file mode 100644
index 0000000..8ca8c8f
--- /dev/null
+++ b/third_party/rules_rust/rust/private/dummy_cc_toolchain/dummy_cc_toolchain.bzl
@@ -0,0 +1,9 @@
+# buildifier: disable=module-docstring
+def _dummy_cc_toolchain_impl(_ctx):
+    # The `all_files` attribute is referenced by rustc_compile_action().
+    return [platform_common.ToolchainInfo(all_files = depset([]))]
+
+dummy_cc_toolchain = rule(
+    implementation = _dummy_cc_toolchain_impl,
+    attrs = {},
+)
diff --git a/third_party/rules_rust/rust/private/providers.bzl b/third_party/rules_rust/rust/private/providers.bzl
new file mode 100644
index 0000000..b471ac0
--- /dev/null
+++ b/third_party/rules_rust/rust/private/providers.bzl
@@ -0,0 +1,109 @@
+# Copyright 2021 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Module containing definitions of all Rust providers."""
+
+CrateInfo = provider(
+    doc = "A provider containing general Crate information.",
+    fields = {
+        "aliases": "Dict[Label, String]: Renamed and aliased crates",
+        "compile_data": "depset[File]: Compile data required by this crate.",
+        "deps": "depset[DepVariantInfo]: This crate's (rust or cc) dependencies' providers.",
+        "edition": "str: The edition of this crate.",
+        "is_test": "bool: If the crate is being compiled in a test context",
+        "name": "str: The name of this crate.",
+        "output": "File: The output File that will be produced, depends on crate type.",
+        "owner": "Label: The label of the target that produced this CrateInfo",
+        "proc_macro_deps": "depset[DepVariantInfo]: This crate's rust proc_macro dependencies' providers.",
+        "root": "File: The source File entrypoint to this crate, eg. lib.rs",
+        "rustc_env": "Dict[String, String]: Additional `\"key\": \"value\"` environment variables to set for rustc.",
+        "srcs": "depset[File]: All source Files that are part of the crate.",
+        "type": (
+            "str: The type of this crate " +
+            "(see [rustc --crate-type](https://doc.rust-lang.org/rustc/command-line-arguments.html#--crate-type-a-list-of-types-of-crates-for-the-compiler-to-emit))."
+        ),
+        "wrapped_crate_type": (
+            "str, optional: The original crate type for targets generated using a previously defined " +
+            "crate (typically tests using the `rust_test::crate` attribute)"
+        ),
+    },
+)
+
+DepInfo = provider(
+    doc = "A provider containing information about a Crate's dependencies.",
+    fields = {
+        "dep_env": "File: File with environment variables direct dependencies build scripts rely upon.",
+        "direct_crates": "depset[AliasableDepInfo]",
+        "link_search_path_files": "depset[File]: All transitive files containing search paths to pass to the linker",
+        "transitive_build_infos": "depset[BuildInfo]",
+        "transitive_crate_outputs": "depset[File]: All transitive crate outputs.",
+        "transitive_crates": "depset[CrateInfo]",
+        "transitive_noncrates": "depset[LinkerInput]: All transitive dependencies that aren't crates.",
+    },
+)
+
+BuildInfo = provider(
+    doc = "A provider containing `rustc` build settings for a given Crate.",
+    fields = {
+        "dep_env": "File: extra build script environment varibles to be set to direct dependencies.",
+        "flags": "File: file containing additional flags to pass to rustc",
+        "link_flags": "File: file containing flags to pass to the linker",
+        "link_search_paths": "File: file containing search paths to pass to the linker",
+        "out_dir": "File: directory containing the result of a build script",
+        "rustc_env": "File: file containing additional environment variables to set for rustc.",
+    },
+)
+
+DepVariantInfo = provider(
+    doc = "A wrapper provider for a dependency of a crate. The dependency can be a Rust " +
+          "dependency, in which case the `crate_info` and `dep_info` fields will be populated, " +
+          "a Rust build script dependency, in which case `build_info` will be populated, or a " +
+          "C/C++ dependency, in which case `cc_info` will be populated.",
+    fields = {
+        "build_info": "BuildInfo: The BuildInfo of a Rust dependency",
+        "cc_info": "CcInfo: The CcInfo of a C/C++ dependency",
+        "crate_info": "CrateInfo: The CrateInfo of a Rust dependency",
+        "dep_info": "DepInfo: The DepInfo of a Rust dependency",
+    },
+)
+
+StdLibInfo = provider(
+    doc = (
+        "A collection of files either found within the `rust-stdlib` artifact or " +
+        "generated based on existing files."
+    ),
+    fields = {
+        "alloc_files": "List[File]: `.a` files related to the `alloc` module.",
+        "between_alloc_and_core_files": "List[File]: `.a` files related to the `compiler_builtins` module.",
+        "between_core_and_std_files": "List[File]: `.a` files related to all modules except `adler`, `alloc`, `compiler_builtins`, `core`, and `std`.",
+        "core_files": "List[File]: `.a` files related to the `core` and `adler` modules",
+        "dot_a_files": "Depset[File]: Generated `.a` files",
+        "self_contained_files": "List[File]: All `.o` files from the `self-contained` directory.",
+        "srcs": "List[Target]: All targets from the original `srcs` attribute.",
+        "std_files": "Depset[File]: `.a` files associated with the `std` module.",
+        "std_rlibs": "List[File]: All `.rlib` files",
+    },
+)
+
+CaptureClippyOutputInfo = provider(
+    doc = "Value of the `capture_clippy_output` build setting",
+    fields = {"capture_output": "Value of the `capture_clippy_output` build setting"},
+)
+
+ClippyInfo = provider(
+    doc = "Provides information on a clippy run.",
+    fields = {
+        "output": "File with the clippy output.",
+    },
+)
diff --git a/third_party/rules_rust/rust/private/repository_utils.bzl b/third_party/rules_rust/rust/private/repository_utils.bzl
new file mode 100644
index 0000000..b6c83aa
--- /dev/null
+++ b/third_party/rules_rust/rust/private/repository_utils.bzl
@@ -0,0 +1,587 @@
+"""Utility macros for use in rules_rust repository rules"""
+
+load("//rust:known_shas.bzl", "FILE_KEY_TO_SHA")
+load(
+    "//rust/platform:triple_mappings.bzl",
+    "system_to_binary_ext",
+    "system_to_dylib_ext",
+    "system_to_staticlib_ext",
+    "system_to_stdlib_linkflags",
+    "triple_to_constraint_set",
+    "triple_to_system",
+)
+
+DEFAULT_TOOLCHAIN_NAME_PREFIX = "toolchain_for"
+DEFAULT_STATIC_RUST_URL_TEMPLATES = ["https://static.rust-lang.org/dist/{}.tar.gz"]
+
+_build_file_for_compiler_template = """\
+load("@rules_rust//rust:toolchain.bzl", "rust_toolchain")
+
+filegroup(
+    name = "rustc",
+    srcs = ["bin/rustc{binary_ext}"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "rustc_lib",
+    srcs = glob(
+        [
+            "bin/*{dylib_ext}",
+            "lib/*{dylib_ext}",
+            "lib/rustlib/{target_triple}/codegen-backends/*{dylib_ext}",
+            "lib/rustlib/{target_triple}/bin/rust-lld{binary_ext}",
+            "lib/rustlib/{target_triple}/lib/*{dylib_ext}",
+        ],
+        allow_empty = True,
+    ),
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "rustdoc",
+    srcs = ["bin/rustdoc{binary_ext}"],
+    visibility = ["//visibility:public"],
+)
+"""
+
+def BUILD_for_compiler(target_triple):
+    """Emits a BUILD file the compiler `.tar.gz`.
+
+    Args:
+        target_triple (str): The triple of the target platform
+
+    Returns:
+        str: The contents of a BUILD file
+    """
+    system = triple_to_system(target_triple)
+    return _build_file_for_compiler_template.format(
+        binary_ext = system_to_binary_ext(system),
+        staticlib_ext = system_to_staticlib_ext(system),
+        dylib_ext = system_to_dylib_ext(system),
+        target_triple = target_triple,
+    )
+
+_build_file_for_cargo_template = """\
+load("@rules_rust//rust:toolchain.bzl", "rust_toolchain")
+
+filegroup(
+    name = "cargo",
+    srcs = ["bin/cargo{binary_ext}"],
+    visibility = ["//visibility:public"],
+)"""
+
+def BUILD_for_cargo(target_triple):
+    """Emits a BUILD file the cargo `.tar.gz`.
+
+    Args:
+        target_triple (str): The triple of the target platform
+
+    Returns:
+        str: The contents of a BUILD file
+    """
+    system = triple_to_system(target_triple)
+    return _build_file_for_cargo_template.format(
+        binary_ext = system_to_binary_ext(system),
+    )
+
+_build_file_for_rustfmt_template = """\
+load("@rules_rust//rust:toolchain.bzl", "rust_toolchain")
+
+filegroup(
+    name = "rustfmt_bin",
+    srcs = ["bin/rustfmt{binary_ext}"],
+    visibility = ["//visibility:public"],
+)
+
+sh_binary(
+    name = "rustfmt",
+    srcs = [":rustfmt_bin"],
+    visibility = ["//visibility:public"],
+)
+"""
+
+def BUILD_for_rustfmt(target_triple):
+    """Emits a BUILD file the rustfmt `.tar.gz`.
+
+    Args:
+        target_triple (str): The triple of the target platform
+
+    Returns:
+        str: The contents of a BUILD file
+    """
+    system = triple_to_system(target_triple)
+    return _build_file_for_rustfmt_template.format(
+        binary_ext = system_to_binary_ext(system),
+    )
+
+_build_file_for_clippy_template = """\
+load("@rules_rust//rust:toolchain.bzl", "rust_toolchain")
+
+filegroup(
+    name = "clippy_driver_bin",
+    srcs = ["bin/clippy-driver{binary_ext}"],
+    visibility = ["//visibility:public"],
+)
+"""
+
+def BUILD_for_clippy(target_triple):
+    """Emits a BUILD file the clippy `.tar.gz`.
+
+    Args:
+        target_triple (str): The triple of the target platform
+
+    Returns:
+        str: The contents of a BUILD file
+    """
+    system = triple_to_system(target_triple)
+    return _build_file_for_clippy_template.format(binary_ext = system_to_binary_ext(system))
+
+_build_file_for_stdlib_template = """\
+load("@rules_rust//rust:toolchain.bzl", "rust_stdlib_filegroup")
+
+rust_stdlib_filegroup(
+    name = "rust_std-{target_triple}",
+    srcs = glob(
+        [
+            "lib/rustlib/{target_triple}/lib/*.rlib",
+            "lib/rustlib/{target_triple}/lib/*{dylib_ext}",
+            "lib/rustlib/{target_triple}/lib/*{staticlib_ext}",
+            "lib/rustlib/{target_triple}/lib/self-contained/**",
+        ],
+        # Some patterns (e.g. `lib/*.a`) don't match anything, see https://github.com/bazelbuild/rules_rust/pull/245
+        allow_empty = True,
+    ),
+    visibility = ["//visibility:public"],
+)
+
+# For legacy support
+alias(
+    name = "rust_lib-{target_triple}",
+    actual = "rust_std-{target_triple}",
+    visibility = ["//visibility:public"],
+)
+"""
+
+def BUILD_for_stdlib(target_triple):
+    """Emits a BUILD file the stdlib `.tar.gz`.
+
+    Args:
+        target_triple (str): The triple of the target platform
+
+    Returns:
+        str: The contents of a BUILD file
+    """
+    system = triple_to_system(target_triple)
+    return _build_file_for_stdlib_template.format(
+        binary_ext = system_to_binary_ext(system),
+        staticlib_ext = system_to_staticlib_ext(system),
+        dylib_ext = system_to_dylib_ext(system),
+        target_triple = target_triple,
+    )
+
+_build_file_for_rust_toolchain_template = """\
+rust_toolchain(
+    name = "{toolchain_name}_impl",
+    rust_doc = "@{workspace_name}//:rustdoc",
+    rust_std = "@{workspace_name}//:rust_std-{target_triple}",
+    rustc = "@{workspace_name}//:rustc",
+    rustfmt = {rustfmt_label},
+    cargo = "@{workspace_name}//:cargo",
+    clippy_driver = "@{workspace_name}//:clippy_driver_bin",
+    rustc_lib = "@{workspace_name}//:rustc_lib",
+    rustc_srcs = {rustc_srcs},
+    binary_ext = "{binary_ext}",
+    staticlib_ext = "{staticlib_ext}",
+    dylib_ext = "{dylib_ext}",
+    stdlib_linkflags = [{stdlib_linkflags}],
+    os = "{system}",
+    default_edition = "{default_edition}",
+    exec_triple = "{exec_triple}",
+    target_triple = "{target_triple}",
+    visibility = ["//visibility:public"],
+)
+"""
+
+def BUILD_for_rust_toolchain(
+        workspace_name,
+        name,
+        exec_triple,
+        target_triple,
+        include_rustc_srcs,
+        default_edition,
+        include_rustfmt,
+        stdlib_linkflags = None):
+    """Emits a toolchain declaration to match an existing compiler and stdlib.
+
+    Args:
+        workspace_name (str): The name of the workspace that this toolchain resides in
+        name (str): The name of the toolchain declaration
+        exec_triple (str): The rust-style target that this compiler runs on
+        target_triple (str): The rust-style target triple of the tool
+        include_rustc_srcs (bool, optional): Whether to download rustc's src code. This is required in order to use rust-analyzer support. Defaults to False.
+        default_edition (str): Default Rust edition.
+        include_rustfmt (bool): Whether rustfmt is present in the toolchain.
+        stdlib_linkflags (list, optional): Overriden flags needed for linking to rust
+                                           stdlib, akin to BAZEL_LINKLIBS. Defaults to
+                                           None.
+
+
+    Returns:
+        str: A rendered template of a `rust_toolchain` declaration
+    """
+    system = triple_to_system(target_triple)
+    if stdlib_linkflags == None:
+        stdlib_linkflags = ", ".join(['"%s"' % x for x in system_to_stdlib_linkflags(system)])
+
+    rustc_srcs = "None"
+    if include_rustc_srcs:
+        rustc_srcs = "\"@{workspace_name}//lib/rustlib/src:rustc_srcs\"".format(workspace_name = workspace_name)
+    rustfmt_label = "None"
+    if include_rustfmt:
+        rustfmt_label = "\"@{workspace_name}//:rustfmt_bin\"".format(workspace_name = workspace_name)
+
+    return _build_file_for_rust_toolchain_template.format(
+        toolchain_name = name,
+        workspace_name = workspace_name,
+        binary_ext = system_to_binary_ext(system),
+        staticlib_ext = system_to_staticlib_ext(system),
+        dylib_ext = system_to_dylib_ext(system),
+        rustc_srcs = rustc_srcs,
+        stdlib_linkflags = stdlib_linkflags,
+        system = system,
+        default_edition = default_edition,
+        exec_triple = exec_triple,
+        target_triple = target_triple,
+        rustfmt_label = rustfmt_label,
+    )
+
+_build_file_for_toolchain_template = """\
+toolchain(
+    name = "{name}",
+    exec_compatible_with = {exec_constraint_sets_serialized},
+    target_compatible_with = {target_constraint_sets_serialized},
+    toolchain = "@{parent_workspace_name}//:{name}_impl",
+    toolchain_type = "@rules_rust//rust:toolchain",
+)
+"""
+
+def BUILD_for_toolchain(name, parent_workspace_name, exec_triple, target_triple):
+    return _build_file_for_toolchain_template.format(
+        name = name,
+        exec_constraint_sets_serialized = serialized_constraint_set_from_triple(exec_triple),
+        target_constraint_sets_serialized = serialized_constraint_set_from_triple(target_triple),
+        parent_workspace_name = parent_workspace_name,
+    )
+
+def load_rustfmt(ctx):
+    """Loads a rustfmt binary and yields corresponding BUILD for it
+
+    Args:
+        ctx (repository_ctx): The repository rule's context object
+
+    Returns:
+        str: The BUILD file contents for this rustfmt binary
+    """
+    target_triple = ctx.attr.exec_triple
+
+    load_arbitrary_tool(
+        ctx,
+        iso_date = ctx.attr.iso_date,
+        target_triple = target_triple,
+        tool_name = "rustfmt",
+        tool_subdirectories = ["rustfmt-preview"],
+        version = ctx.attr.rustfmt_version,
+    )
+
+    return BUILD_for_rustfmt(target_triple)
+
+def load_rust_compiler(ctx):
+    """Loads a rust compiler and yields corresponding BUILD for it
+
+    Args:
+        ctx (repository_ctx): A repository_ctx.
+
+    Returns:
+        str: The BUILD file contents for this compiler and compiler library
+    """
+
+    target_triple = ctx.attr.exec_triple
+    load_arbitrary_tool(
+        ctx,
+        iso_date = ctx.attr.iso_date,
+        target_triple = target_triple,
+        tool_name = "rust",
+        tool_subdirectories = ["rustc", "clippy-preview", "cargo"],
+        version = ctx.attr.version,
+    )
+
+    compiler_build_file = BUILD_for_compiler(target_triple) + BUILD_for_clippy(target_triple) + BUILD_for_cargo(target_triple)
+
+    return compiler_build_file
+
+def should_include_rustc_srcs(repository_ctx):
+    """Determing whether or not to include rustc sources in the toolchain.
+
+    Args:
+        repository_ctx (repository_ctx): The repository rule's context object
+
+    Returns:
+        bool: Whether or not to include rustc source files in a `rustc_toolchain`
+    """
+
+    # The environment variable will always take precedence over the attribute.
+    include_rustc_srcs_env = repository_ctx.os.environ.get("RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS")
+    if include_rustc_srcs_env != None:
+        return include_rustc_srcs_env.lower() in ["true", "1"]
+
+    return getattr(repository_ctx.attr, "include_rustc_srcs", False)
+
+def load_rust_src(ctx):
+    """Loads the rust source code. Used by the rust-analyzer rust-project.json generator.
+
+    Args:
+        ctx (ctx): A repository_ctx.
+    """
+    tool_suburl = produce_tool_suburl("rust-src", None, ctx.attr.version, ctx.attr.iso_date)
+    static_rust = ctx.os.environ.get("STATIC_RUST_URL", "https://static.rust-lang.org")
+    url = "{}/dist/{}.tar.gz".format(static_rust, tool_suburl)
+
+    tool_path = produce_tool_path("rust-src", None, ctx.attr.version)
+    archive_path = tool_path + ".tar.gz"
+    ctx.download(
+        url,
+        output = archive_path,
+        sha256 = ctx.attr.sha256s.get(tool_suburl) or FILE_KEY_TO_SHA.get(tool_suburl) or "",
+        auth = _make_auth_dict(ctx, [url]),
+    )
+    ctx.extract(
+        archive_path,
+        output = "lib/rustlib/src",
+        stripPrefix = "{}/rust-src/lib/rustlib/src/rust".format(tool_path),
+    )
+    ctx.file(
+        "lib/rustlib/src/BUILD.bazel",
+        """\
+filegroup(
+    name = "rustc_srcs",
+    srcs = glob(["**/*"]),
+    visibility = ["//visibility:public"],
+)""",
+    )
+
+def load_rust_stdlib(ctx, target_triple):
+    """Loads a rust standard library and yields corresponding BUILD for it
+
+    Args:
+        ctx (repository_ctx): A repository_ctx.
+        target_triple (str): The rust-style target triple of the tool
+
+    Returns:
+        str: The BUILD file contents for this stdlib, and a toolchain decl to match
+    """
+
+    load_arbitrary_tool(
+        ctx,
+        iso_date = ctx.attr.iso_date,
+        target_triple = target_triple,
+        tool_name = "rust-std",
+        tool_subdirectories = ["rust-std-{}".format(target_triple)],
+        version = ctx.attr.version,
+    )
+
+    toolchain_prefix = ctx.attr.toolchain_name_prefix or DEFAULT_TOOLCHAIN_NAME_PREFIX
+    stdlib_build_file = BUILD_for_stdlib(target_triple)
+
+    stdlib_linkflags = None
+    if "BAZEL_RUST_STDLIB_LINKFLAGS" in ctx.os.environ:
+        stdlib_linkflags = ctx.os.environ["BAZEL_RUST_STDLIB_LINKFLAGS"].split(":")
+
+    toolchain_build_file = BUILD_for_rust_toolchain(
+        name = "{toolchain_prefix}_{target_triple}".format(
+            toolchain_prefix = toolchain_prefix,
+            target_triple = target_triple,
+        ),
+        exec_triple = ctx.attr.exec_triple,
+        include_rustc_srcs = should_include_rustc_srcs(ctx),
+        target_triple = target_triple,
+        stdlib_linkflags = stdlib_linkflags,
+        workspace_name = ctx.attr.name,
+        default_edition = ctx.attr.edition,
+        include_rustfmt = not (not ctx.attr.rustfmt_version),
+    )
+
+    return stdlib_build_file + toolchain_build_file
+
+def load_rustc_dev_nightly(ctx, target_triple):
+    """Loads the nightly rustc dev component
+
+    Args:
+        ctx: A repository_ctx.
+        target_triple: The rust-style target triple of the tool
+    """
+
+    subdir_name = "rustc-dev"
+    if ctx.attr.iso_date < "2020-12-24":
+        subdir_name = "rustc-dev-{}".format(target_triple)
+
+    load_arbitrary_tool(
+        ctx,
+        iso_date = ctx.attr.iso_date,
+        target_triple = target_triple,
+        tool_name = "rustc-dev",
+        tool_subdirectories = [subdir_name],
+        version = ctx.attr.version,
+    )
+
+def load_llvm_tools(ctx, target_triple):
+    """Loads the llvm tools
+
+    Args:
+        ctx: A repository_ctx.
+        target_triple: The rust-style target triple of the tool
+    """
+    load_arbitrary_tool(
+        ctx,
+        iso_date = ctx.attr.iso_date,
+        target_triple = target_triple,
+        tool_name = "llvm-tools",
+        tool_subdirectories = ["llvm-tools-preview"],
+        version = ctx.attr.version,
+    )
+
+def check_version_valid(version, iso_date, param_prefix = ""):
+    """Verifies that the provided rust version and iso_date make sense.
+
+    Args:
+        version (str): The rustc version
+        iso_date (str): The rustc nightly version's iso date
+        param_prefix (str, optional): The name of the tool who's version is being checked.
+    """
+
+    if not version and iso_date:
+        fail("{param_prefix}iso_date must be paired with a {param_prefix}version".format(param_prefix = param_prefix))
+
+    if version in ("beta", "nightly") and not iso_date:
+        fail("{param_prefix}iso_date must be specified if version is 'beta' or 'nightly'".format(param_prefix = param_prefix))
+
+def serialized_constraint_set_from_triple(target_triple):
+    """Returns a string representing a set of constraints
+
+    Args:
+        target_triple (str): The target triple of the constraint set
+
+    Returns:
+        str: Formatted string representing the serialized constraint
+    """
+    constraint_set = triple_to_constraint_set(target_triple)
+    constraint_set_strs = []
+    for constraint in constraint_set:
+        constraint_set_strs.append("\"{}\"".format(constraint))
+    return "[{}]".format(", ".join(constraint_set_strs))
+
+def produce_tool_suburl(tool_name, target_triple, version, iso_date = None):
+    """Produces a fully qualified Rust tool name for URL
+
+    Args:
+        tool_name: The name of the tool per static.rust-lang.org
+        target_triple: The rust-style target triple of the tool
+        version: The version of the tool among "nightly", "beta', or an exact version.
+        iso_date: The date of the tool (or None, if the version is a specific version).
+
+    Returns:
+        str: The fully qualified url path for the specified tool.
+    """
+    path = produce_tool_path(tool_name, target_triple, version)
+    return iso_date + "/" + path if (iso_date and version in ("beta", "nightly")) else path
+
+def produce_tool_path(tool_name, target_triple, version):
+    """Produces a qualified Rust tool name
+
+    Args:
+        tool_name: The name of the tool per static.rust-lang.org
+        target_triple: The rust-style target triple of the tool
+        version: The version of the tool among "nightly", "beta', or an exact version.
+
+    Returns:
+        str: The qualified path for the specified tool.
+    """
+    if not tool_name:
+        fail("No tool name was provided")
+    if not version:
+        fail("No tool version was provided")
+    return "-".join([e for e in [tool_name, version, target_triple] if e])
+
+def load_arbitrary_tool(ctx, tool_name, tool_subdirectories, version, iso_date, target_triple, sha256 = ""):
+    """Loads a Rust tool, downloads, and extracts into the common workspace.
+
+    This function sources the tool from the Rust-lang static file server. The index is available at:
+    - https://static.rust-lang.org/dist/channel-rust-stable.toml
+    - https://static.rust-lang.org/dist/channel-rust-beta.toml
+    - https://static.rust-lang.org/dist/channel-rust-nightly.toml
+
+    The environment variable `STATIC_RUST_URL` can be used to replace the schema and hostname of
+    the URLs used for fetching assets. `https://static.rust-lang.org/dist/channel-rust-stable.toml`
+    becomes `${STATIC_RUST_URL}/dist/channel-rust-stable.toml`
+
+    Args:
+        ctx (repository_ctx): A repository_ctx (no attrs required).
+        tool_name (str): The name of the given tool per the archive naming.
+        tool_subdirectories (str): The subdirectories of the tool files (at a level below the root directory of
+            the archive). The root directory of the archive is expected to match
+            $TOOL_NAME-$VERSION-$TARGET_TRIPLE.
+            Example:
+            tool_name
+            |    version
+            |    |      target_triple
+            v    v      v
+            rust-1.39.0-x86_64-unknown-linux-gnu/clippy-preview
+                                             .../rustc
+                                             .../etc
+            tool_subdirectories = ["clippy-preview", "rustc"]
+        version (str): The version of the tool among "nightly", "beta', or an exact version.
+        iso_date (str): The date of the tool (ignored if the version is a specific version).
+        target_triple (str): The rust-style target triple of the tool
+        sha256 (str, optional): The expected hash of hash of the Rust tool. Defaults to "".
+    """
+    check_version_valid(version, iso_date, param_prefix = tool_name + "_")
+
+    # View the indices mentioned in the docstring to find the tool_suburl for a given
+    # tool.
+    tool_suburl = produce_tool_suburl(tool_name, target_triple, version, iso_date)
+    urls = []
+
+    static_rust_url_from_env = ctx.os.environ.get("STATIC_RUST_URL")
+    if static_rust_url_from_env:
+        urls.append("{}/dist/{}.tar.gz".format(static_rust_url_from_env, tool_suburl))
+
+    for url in getattr(ctx.attr, "urls", DEFAULT_STATIC_RUST_URL_TEMPLATES):
+        new_url = url.format(tool_suburl)
+        if new_url not in urls:
+            urls.append(new_url)
+
+    tool_path = produce_tool_path(tool_name, target_triple, version)
+    archive_path = "{}.tar.gz".format(tool_path)
+    ctx.download(
+        urls,
+        output = archive_path,
+        sha256 = getattr(ctx.attr, "sha256s", dict()).get(tool_suburl) or
+                 FILE_KEY_TO_SHA.get(tool_suburl) or
+                 sha256,
+        auth = _make_auth_dict(ctx, urls),
+    )
+    for subdirectory in tool_subdirectories:
+        ctx.extract(
+            archive_path,
+            output = "",
+            stripPrefix = "{}/{}".format(tool_path, subdirectory),
+        )
+
+def _make_auth_dict(ctx, urls):
+    auth = getattr(ctx.attr, "auth", {})
+    if not auth:
+        return {}
+    ret = {}
+    for url in urls:
+        ret[url] = auth
+    return ret
diff --git a/third_party/rules_rust/rust/private/rust.bzl b/third_party/rules_rust/rust/private/rust.bzl
new file mode 100644
index 0000000..58cc9c4
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rust.bzl
@@ -0,0 +1,1151 @@
+# Copyright 2015 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:rustc.bzl", "rustc_compile_action")
+load(
+    "//rust/private:utils.bzl",
+    "compute_crate_name",
+    "dedent",
+    "determine_output_hash",
+    "expand_dict_value_locations",
+    "find_toolchain",
+    "get_import_macro_deps",
+    "transform_deps",
+)
+
+# TODO(marco): Separate each rule into its own file.
+
+def _assert_no_deprecated_attributes(_ctx):
+    """Forces a failure if any deprecated attributes were specified
+
+    Args:
+        _ctx (ctx): The current rule's context object
+    """
+    pass
+
+def _assert_correct_dep_mapping(ctx):
+    """Forces a failure if proc_macro_deps and deps are mixed inappropriately
+
+    Args:
+        ctx (ctx): The current rule's context object
+    """
+    for dep in ctx.attr.deps:
+        if rust_common.crate_info in dep:
+            if dep[rust_common.crate_info].type == "proc-macro":
+                fail(
+                    "{} listed {} in its deps, but it is a proc-macro. It should instead be in the bazel property proc_macro_deps.".format(
+                        ctx.label,
+                        dep.label,
+                    ),
+                )
+    for dep in ctx.attr.proc_macro_deps:
+        type = dep[rust_common.crate_info].type
+        if type != "proc-macro":
+            fail(
+                "{} listed {} in its proc_macro_deps, but it is not proc-macro, it is a {}. It should probably instead be listed in deps.".format(
+                    ctx.label,
+                    dep.label,
+                    type,
+                ),
+            )
+
+def _determine_lib_name(name, crate_type, toolchain, lib_hash = None):
+    """See https://github.com/bazelbuild/rules_rust/issues/405
+
+    Args:
+        name (str): The name of the current target
+        crate_type (str): The `crate_type`
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        lib_hash (str, optional): The hashed crate root path
+
+    Returns:
+        str: A unique library name
+    """
+    extension = None
+    prefix = ""
+    if crate_type in ("dylib", "cdylib", "proc-macro"):
+        extension = toolchain.dylib_ext
+    elif crate_type == "staticlib":
+        extension = toolchain.staticlib_ext
+    elif crate_type in ("lib", "rlib"):
+        # All platforms produce 'rlib' here
+        extension = ".rlib"
+        prefix = "lib"
+    elif crate_type == "bin":
+        fail("crate_type of 'bin' was detected in a rust_library. Please compile " +
+             "this crate as a rust_binary instead.")
+
+    if not extension:
+        fail(("Unknown crate_type: {}. If this is a cargo-supported crate type, " +
+              "please file an issue!").format(crate_type))
+
+    prefix = "lib"
+    if (toolchain.target_triple.find("windows") != -1) and crate_type not in ("lib", "rlib"):
+        prefix = ""
+    if toolchain.target_arch == "wasm32" and crate_type == "cdylib":
+        prefix = ""
+
+    return "{prefix}{name}{lib_hash}{extension}".format(
+        prefix = prefix,
+        name = name,
+        lib_hash = "-" + lib_hash if lib_hash else "",
+        extension = extension,
+    )
+
+def get_edition(attr, toolchain):
+    """Returns the Rust edition from either the current rule's attirbutes or the current `rust_toolchain`
+
+    Args:
+        attr (struct): The current rule's attributes
+        toolchain (rust_toolchain): The `rust_toolchain` for the current target
+
+    Returns:
+        str: The target Rust edition
+    """
+    if getattr(attr, "edition"):
+        return attr.edition
+    else:
+        return toolchain.default_edition
+
+def crate_root_src(attr, srcs, crate_type):
+    """Finds the source file for the crate root.
+
+    Args:
+        attr (struct): The attributes of the current target
+        srcs (list): A list of all sources for the target Crate.
+        crate_type (str): The type of this crate ("bin", "lib", "rlib", "cdylib", etc).
+
+    Returns:
+        File: The root File object for a given crate. See the following links for more details:
+            - https://doc.rust-lang.org/cargo/reference/cargo-targets.html#library
+            - https://doc.rust-lang.org/cargo/reference/cargo-targets.html#binaries
+    """
+    default_crate_root_filename = "main.rs" if crate_type == "bin" else "lib.rs"
+
+    crate_root = None
+    if hasattr(attr, "crate_root"):
+        if attr.crate_root:
+            crate_root = attr.crate_root.files.to_list()[0]
+
+    if not crate_root:
+        crate_root = (
+            (srcs[0] if len(srcs) == 1 else None) or
+            _shortest_src_with_basename(srcs, default_crate_root_filename) or
+            _shortest_src_with_basename(srcs, attr.name + ".rs")
+        )
+    if not crate_root:
+        file_names = [default_crate_root_filename, attr.name + ".rs"]
+        fail("No {} source file found.".format(" or ".join(file_names)), "srcs")
+    return crate_root
+
+def _shortest_src_with_basename(srcs, basename):
+    """Finds the shortest among the paths in srcs that match the desired basename.
+
+    Args:
+        srcs (list): A list of File objects
+        basename (str): The target basename to match against.
+
+    Returns:
+        File: The File object with the shortest path that matches `basename`
+    """
+    shortest = None
+    for f in srcs:
+        if f.basename == basename:
+            if not shortest or len(f.dirname) < len(shortest.dirname):
+                shortest = f
+    return shortest
+
+def _rust_library_impl(ctx):
+    """The implementation of the `rust_library` rule.
+
+    This rule provides CcInfo, so it can be used everywhere Bazel
+    expects rules_cc, but care must be taken to have the correct
+    dependencies on an allocator and std implemetation as needed.
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers.
+    """
+    return _rust_library_common(ctx, "rlib")
+
+def _rust_static_library_impl(ctx):
+    """The implementation of the `rust_static_library` rule.
+
+    This rule provides CcInfo, so it can be used everywhere Bazel
+    expects rules_cc.
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers.
+    """
+    return _rust_library_common(ctx, "staticlib")
+
+def _rust_shared_library_impl(ctx):
+    """The implementation of the `rust_shared_library` rule.
+
+    This rule provides CcInfo, so it can be used everywhere Bazel
+    expects rules_cc.
+
+    On Windows, a PDB file containing debugging information is available under
+    the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
+    is available under the key `dsym_folder` in `OutputGroupInfo`.
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers.
+    """
+    return _rust_library_common(ctx, "cdylib")
+
+def _rust_proc_macro_impl(ctx):
+    """The implementation of the `rust_proc_macro` rule.
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers.
+    """
+    return _rust_library_common(ctx, "proc-macro")
+
+def _rust_library_common(ctx, crate_type):
+    """The common implementation of the library-like rules.
+
+    Args:
+        ctx (ctx): The rule's context object
+        crate_type (String): one of lib|rlib|dylib|staticlib|cdylib|proc-macro
+
+    Returns:
+        list: A list of providers. See `rustc_compile_action`
+    """
+
+    # Find lib.rs
+    crate_root = crate_root_src(ctx.attr, ctx.files.srcs, "lib")
+    _assert_no_deprecated_attributes(ctx)
+    _assert_correct_dep_mapping(ctx)
+
+    toolchain = find_toolchain(ctx)
+
+    # Determine unique hash for this rlib.
+    # Note that we don't include a hash for `cdylib` since they are meant to be consumed externally and having a
+    # deterministic name is important since it ends up embedded in the executable. This is problematic when one needs
+    # to include the library with a specific filename into a larger application.
+    # (see https://github.com/bazelbuild/rules_rust/issues/405#issuecomment-993089889 for more details)
+    if crate_type != "cdylib":
+        output_hash = determine_output_hash(crate_root, ctx.label)
+    else:
+        output_hash = None
+
+    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name)
+    rust_lib_name = _determine_lib_name(
+        crate_name,
+        crate_type,
+        toolchain,
+        output_hash,
+    )
+    rust_lib = ctx.actions.declare_file(rust_lib_name)
+
+    deps = transform_deps(ctx.attr.deps)
+    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
+
+    return rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = crate_type,
+            root = crate_root,
+            srcs = depset(ctx.files.srcs),
+            deps = depset(deps),
+            proc_macro_deps = depset(proc_macro_deps),
+            aliases = ctx.attr.aliases,
+            output = rust_lib,
+            edition = get_edition(ctx.attr, toolchain),
+            rustc_env = ctx.attr.rustc_env,
+            is_test = False,
+            compile_data = depset(ctx.files.compile_data),
+            owner = ctx.label,
+        ),
+        output_hash = output_hash,
+    )
+
+def _rust_binary_impl(ctx):
+    """The implementation of the `rust_binary` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers. See `rustc_compile_action`
+    """
+    toolchain = find_toolchain(ctx)
+    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name)
+    _assert_correct_dep_mapping(ctx)
+
+    output = ctx.actions.declare_file(ctx.label.name + toolchain.binary_ext)
+
+    deps = transform_deps(ctx.attr.deps)
+    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
+
+    return rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = ctx.attr.crate_type,
+            root = crate_root_src(ctx.attr, ctx.files.srcs, ctx.attr.crate_type),
+            srcs = depset(ctx.files.srcs),
+            deps = depset(deps),
+            proc_macro_deps = depset(proc_macro_deps),
+            aliases = ctx.attr.aliases,
+            output = output,
+            edition = get_edition(ctx.attr, toolchain),
+            rustc_env = ctx.attr.rustc_env,
+            is_test = False,
+            compile_data = depset(ctx.files.compile_data),
+            owner = ctx.label,
+        ),
+    )
+
+def _rust_test_common(ctx, toolchain, output):
+    """Builds a Rust test binary.
+
+    Args:
+        ctx (ctx): The ctx object for the current target.
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        output (File): The output File that will be produced, depends on crate type.
+
+    Returns:
+        list: The list of providers. See `rustc_compile_action`
+    """
+    _assert_no_deprecated_attributes(ctx)
+    _assert_correct_dep_mapping(ctx)
+
+    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name)
+    crate_type = "bin"
+
+    deps = transform_deps(ctx.attr.deps)
+    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
+
+    if ctx.attr.crate:
+        # Target is building the crate in `test` config
+        crate = ctx.attr.crate[rust_common.crate_info]
+
+        # Optionally join compile data
+        if crate.compile_data:
+            compile_data = depset(ctx.files.compile_data, transitive = [crate.compile_data])
+        else:
+            compile_data = depset(ctx.files.compile_data)
+
+        # Build the test binary using the dependency's srcs.
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = crate_type,
+            root = crate.root,
+            srcs = depset(ctx.files.srcs, transitive = [crate.srcs]),
+            deps = depset(deps, transitive = [crate.deps]),
+            proc_macro_deps = depset(proc_macro_deps, transitive = [crate.proc_macro_deps]),
+            aliases = ctx.attr.aliases,
+            output = output,
+            edition = crate.edition,
+            rustc_env = ctx.attr.rustc_env,
+            is_test = True,
+            compile_data = compile_data,
+            wrapped_crate_type = crate.type,
+            owner = ctx.label,
+        )
+    else:
+        # Target is a standalone crate. Build the test binary as its own crate.
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = crate_type,
+            root = crate_root_src(ctx.attr, ctx.files.srcs, "lib"),
+            srcs = depset(ctx.files.srcs),
+            deps = depset(deps),
+            proc_macro_deps = depset(proc_macro_deps),
+            aliases = ctx.attr.aliases,
+            output = output,
+            edition = get_edition(ctx.attr, toolchain),
+            rustc_env = ctx.attr.rustc_env,
+            is_test = True,
+            compile_data = depset(ctx.files.compile_data),
+            owner = ctx.label,
+        )
+
+    providers = rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = crate_info,
+        rust_flags = ["--test"] if ctx.attr.use_libtest_harness else ["--cfg", "test"],
+    )
+    data = getattr(ctx.attr, "data", [])
+
+    env = expand_dict_value_locations(
+        ctx,
+        getattr(ctx.attr, "env", {}),
+        data,
+    )
+    providers.append(testing.TestEnvironment(env))
+
+    return providers
+
+def _rust_test_impl(ctx):
+    """The implementation of the `rust_test` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list of providers. See `_rust_test_common`
+    """
+    toolchain = find_toolchain(ctx)
+
+    output = ctx.actions.declare_file(
+        ctx.label.name + toolchain.binary_ext,
+    )
+
+    return _rust_test_common(ctx, toolchain, output)
+
+_common_attrs = {
+    "aliases": attr.label_keyed_string_dict(
+        doc = dedent("""\
+            Remap crates to a new name or moniker for linkage to this target
+
+            These are other `rust_library` targets and will be presented as the new name given.
+        """),
+    ),
+    "compile_data": attr.label_list(
+        doc = dedent("""\
+            List of files used by this rule at compile time.
+
+            This attribute can be used to specify any data files that are embedded into
+            the library, such as via the
+            [`include_str!`](https://doc.rust-lang.org/std/macro.include_str!.html)
+            macro.
+        """),
+        allow_files = True,
+    ),
+    "crate_features": attr.string_list(
+        doc = dedent("""\
+            List of features to enable for this crate.
+
+            Features are defined in the code using the `#[cfg(feature = "foo")]`
+            configuration option. The features listed here will be passed to `rustc`
+            with `--cfg feature="${feature_name}"` flags.
+        """),
+    ),
+    "crate_name": attr.string(
+        doc = dedent("""\
+            Crate name to use for this target.
+
+            This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores.
+            Defaults to the target name, with any hyphens replaced by underscores.
+        """),
+    ),
+    "crate_root": attr.label(
+        doc = dedent("""\
+            The file that will be passed to `rustc` to be used for building this crate.
+
+            If `crate_root` is not set, then this rule will look for a `lib.rs` file (or `main.rs` for rust_binary)
+            or the single file in `srcs` if `srcs` contains only one file.
+        """),
+        allow_single_file = [".rs"],
+    ),
+    "data": attr.label_list(
+        doc = dedent("""\
+            List of files used by this rule at compile time and runtime.
+
+            If including data at compile time with include_str!() and similar,
+            prefer `compile_data` over `data`, to prevent the data also being included
+            in the runfiles.
+        """),
+        allow_files = True,
+    ),
+    "deps": attr.label_list(
+        doc = dedent("""\
+            List of other libraries to be linked to this library target.
+
+            These can be either other `rust_library` targets or `cc_library` targets if
+            linking a native library.
+        """),
+    ),
+    "edition": attr.string(
+        doc = "The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.",
+    ),
+    # Previously `proc_macro_deps` were a part of `deps`, and then proc_macro_host_transition was
+    # used into cfg="host" using `@local_config_platform//:host`.
+    # This fails for remote execution, which needs cfg="exec", and there isn't anything like
+    # `@local_config_platform//:exec` exposed.
+    "proc_macro_deps": attr.label_list(
+        doc = dedent("""\
+            List of `rust_library` targets with kind `proc-macro` used to help build this library target.
+        """),
+        cfg = "exec",
+        providers = [rust_common.crate_info],
+    ),
+    "rustc_env": attr.string_dict(
+        doc = dedent("""\
+            Dictionary of additional `"key": "value"` environment variables to set for rustc.
+
+            rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the
+            location of a generated file or external tool. Cargo build scripts that wish to
+            expand locations should use cargo_build_script()'s build_script_env argument instead,
+            as build scripts are run in a different environment - see cargo_build_script()'s
+            documentation for more.
+        """),
+    ),
+    "rustc_env_files": attr.label_list(
+        doc = dedent("""\
+            Files containing additional environment variables to set for rustc.
+
+            These files should  contain a single variable per line, of format
+            `NAME=value`, and newlines may be included in a value by ending a
+            line with a trailing back-slash (`\\\\`).
+
+            The order that these files will be processed is unspecified, so
+            multiple definitions of a particular variable are discouraged.
+
+            Note that the variables here are subject to 
+            [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status)
+            stamping should the `stamp` attribute be enabled. Stamp variables
+            should be wrapped in brackets in order to be resolved. E.g.
+            `NAME={WORKSPACE_STATUS_VARIABLE}`.
+        """),
+        allow_files = True,
+    ),
+    "rustc_flags": attr.string_list(
+        doc = dedent("""\
+            List of compiler flags passed to `rustc`.
+
+            These strings are subject to Make variable expansion for predefined
+            source/output path variables like `$location`, `$execpath`, and 
+            `$rootpath`. This expansion is useful if you wish to pass a generated
+            file of arguments to rustc: `@$(location //package:target)`.
+        """),
+    ),
+    # TODO(stardoc): How do we provide additional documentation to an inherited attribute?
+    # "name": attr.string(
+    #     doc = "This name will also be used as the name of the crate built by this rule.",
+    # `),
+    "srcs": attr.label_list(
+        doc = dedent("""\
+            List of Rust `.rs` source files used to build the library.
+
+            If `srcs` contains more than one file, then there must be a file either
+            named `lib.rs`. Otherwise, `crate_root` must be set to the source file that
+            is the root of the crate to be passed to rustc to build this crate.
+        """),
+        allow_files = [".rs"],
+    ),
+    "stamp": attr.int(
+        doc = dedent("""\
+            Whether to encode build information into the `Rustc` action. Possible values:
+
+            - `stamp = 1`: Always stamp the build information into the `Rustc` action, even in \
+            [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds. \
+            This setting should be avoided, since it potentially kills remote caching for the target and \
+            any downstream actions that depend on it.
+
+            - `stamp = 0`: Always replace build information by constant values. This gives good build result caching.
+
+            - `stamp = -1`: Embedding of build information is controlled by the \
+            [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.
+
+            Stamped targets are not rebuilt unless their dependencies change.
+
+            For example if a `rust_library` is stamped, and a `rust_binary` depends on that library, the stamped
+            library won't be rebuilt when we change sources of the `rust_binary`. This is different from how
+            [`cc_library.linkstamps`](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp)
+            behaves.
+        """),
+        default = -1,
+        values = [1, 0, -1],
+    ),
+    "version": attr.string(
+        doc = "A version to inject in the cargo environment variable.",
+        default = "0.0.0",
+    ),
+    "_cc_toolchain": attr.label(
+        default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+    ),
+    "_error_format": attr.label(default = "//:error_format"),
+    "_extra_exec_rustc_flags": attr.label(default = "//:extra_exec_rustc_flags"),
+    "_extra_rustc_flags": attr.label(default = "//:extra_rustc_flags"),
+    "_import_macro_dep": attr.label(
+        default = "@rules_rust//util/import",
+    ),
+    "_process_wrapper": attr.label(
+        default = Label("//util/process_wrapper"),
+        executable = True,
+        allow_single_file = True,
+        cfg = "exec",
+    ),
+    "_stamp_flag": attr.label(
+        doc = "A setting used to determine whether or not the `--stamp` flag is enabled",
+        default = Label("//rust/private:stamp"),
+    ),
+}
+
+_rust_test_attrs = {
+    "crate": attr.label(
+        mandatory = False,
+        doc = dedent("""\
+            Target inline tests declared in the given crate
+
+            These tests are typically those that would be held out under
+            `#[cfg(test)]` declarations.
+        """),
+    ),
+    "env": attr.string_dict(
+        mandatory = False,
+        doc = dedent("""\
+            Specifies additional environment variables to set when the test is executed by bazel test.
+            Values are subject to `$(rootpath)`, `$(execpath)`, location, and
+            ["Make variable"](https://docs.bazel.build/versions/master/be/make-variables.html) substitution.
+
+            Execpath returns absolute path, and in order to be able to construct the absolute path we
+            need to wrap the test binary in a launcher. Using a launcher comes with complications, such as
+            more complicated debugger attachment.
+        """),
+    ),
+    "use_libtest_harness": attr.bool(
+        mandatory = False,
+        default = True,
+        doc = dedent("""\
+            Whether to use `libtest`. For targets using this flag, individual tests can be run by using the 
+            [--test_arg](https://docs.bazel.build/versions/4.0.0/command-line-reference.html#flag--test_arg) flag.
+            E.g. `bazel test //src:rust_test --test_arg=foo::test::test_fn`.
+        """),
+    ),
+    "_grep_includes": attr.label(
+        allow_single_file = True,
+        cfg = "exec",
+        default = Label("@bazel_tools//tools/cpp:grep-includes"),
+        executable = True,
+    ),
+}
+
+_common_providers = [
+    rust_common.crate_info,
+    rust_common.dep_info,
+    DefaultInfo,
+]
+
+rust_library = rule(
+    implementation = _rust_library_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items()),
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust library crate.
+
+        Example:
+
+        Suppose you have the following directory structure for a simple Rust library crate:
+
+        ```output
+        [workspace]/
+            WORKSPACE
+            hello_lib/
+                BUILD
+                src/
+                    greeter.rs
+                    lib.rs
+        ```
+
+        `hello_lib/src/greeter.rs`:
+        ```rust
+        pub struct Greeter {
+            greeting: String,
+        }
+
+        impl Greeter {
+            pub fn new(greeting: &str) -> Greeter {
+                Greeter { greeting: greeting.to_string(), }
+            }
+
+            pub fn greet(&self, thing: &str) {
+                println!("{} {}", &self.greeting, thing);
+            }
+        }
+        ```
+
+        `hello_lib/src/lib.rs`:
+
+        ```rust
+        pub mod greeter;
+        ```
+
+        `hello_lib/BUILD`:
+        ```python
+        package(default_visibility = ["//visibility:public"])
+
+        load("@rules_rust//rust:defs.bzl", "rust_library")
+
+        rust_library(
+            name = "hello_lib",
+            srcs = [
+                "src/greeter.rs",
+                "src/lib.rs",
+            ],
+        )
+        ```
+
+        Build the library:
+        ```output
+        $ bazel build //hello_lib
+        INFO: Found 1 target...
+        Target //examples/rust/hello_lib:hello_lib up-to-date:
+        bazel-bin/examples/rust/hello_lib/libhello_lib.rlib
+        INFO: Elapsed time: 1.245s, Critical Path: 1.01s
+        ```
+        """),
+)
+
+rust_static_library = rule(
+    implementation = _rust_static_library_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items()),
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust static library.
+
+        This static library will contain all transitively reachable crates and native objects.
+        It is meant to be used when producing an artifact that is then consumed by some other build system
+        (for example to produce an archive that Python program links against).
+
+        This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+        When building the whole binary in Bazel, use `rust_library` instead.
+        """),
+)
+
+rust_shared_library = rule(
+    implementation = _rust_shared_library_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items()),
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust shared library.
+
+        This shared library will contain all transitively reachable crates and native objects.
+        It is meant to be used when producing an artifact that is then consumed by some other build system
+        (for example to produce a shared library that Python program links against).
+
+        This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
+
+        When building the whole binary in Bazel, use `rust_library` instead.
+        """),
+)
+
+rust_proc_macro = rule(
+    implementation = _rust_proc_macro_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items()),
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust proc-macro crate.
+        """),
+)
+
+_rust_binary_attrs = {
+    "crate_type": attr.string(
+        doc = dedent("""\
+            Crate type that will be passed to `rustc` to be used for building this crate.
+
+            This option is a temporary workaround and should be used only when building
+            for WebAssembly targets (//rust/platform:wasi and //rust/platform:wasm).
+        """),
+        default = "bin",
+    ),
+    "linker_script": attr.label(
+        doc = dedent("""\
+            Link script to forward into linker via rustc options.
+        """),
+        cfg = "exec",
+        allow_single_file = True,
+    ),
+    "out_binary": attr.bool(
+        doc = (
+            "Force a target, regardless of it's `crate_type`, to always mark the " +
+            "file as executable. This attribute is only used to support wasm targets but is " +
+            "expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771."
+        ),
+        default = False,
+    ),
+    "_grep_includes": attr.label(
+        allow_single_file = True,
+        cfg = "exec",
+        default = Label("@bazel_tools//tools/cpp:grep-includes"),
+        executable = True,
+    ),
+}
+
+rust_binary = rule(
+    implementation = _rust_binary_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items() + _rust_binary_attrs.items()),
+    executable = True,
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust binary crate.
+
+        Example:
+
+        Suppose you have the following directory structure for a Rust project with a
+        library crate, `hello_lib`, and a binary crate, `hello_world` that uses the
+        `hello_lib` library:
+
+        ```output
+        [workspace]/
+            WORKSPACE
+            hello_lib/
+                BUILD
+                src/
+                    lib.rs
+            hello_world/
+                BUILD
+                src/
+                    main.rs
+        ```
+
+        `hello_lib/src/lib.rs`:
+        ```rust
+        pub struct Greeter {
+            greeting: String,
+        }
+
+        impl Greeter {
+            pub fn new(greeting: &str) -> Greeter {
+                Greeter { greeting: greeting.to_string(), }
+            }
+
+            pub fn greet(&self, thing: &str) {
+                println!("{} {}", &self.greeting, thing);
+            }
+        }
+        ```
+
+        `hello_lib/BUILD`:
+        ```python
+        package(default_visibility = ["//visibility:public"])
+
+        load("@rules_rust//rust:defs.bzl", "rust_library")
+
+        rust_library(
+            name = "hello_lib",
+            srcs = ["src/lib.rs"],
+        )
+        ```
+
+        `hello_world/src/main.rs`:
+        ```rust
+        extern crate hello_lib;
+
+        fn main() {
+            let hello = hello_lib::Greeter::new("Hello");
+            hello.greet("world");
+        }
+        ```
+
+        `hello_world/BUILD`:
+        ```python
+        load("@rules_rust//rust:defs.bzl", "rust_binary")
+
+        rust_binary(
+            name = "hello_world",
+            srcs = ["src/main.rs"],
+            deps = ["//hello_lib"],
+        )
+        ```
+
+        Build and run `hello_world`:
+        ```
+        $ bazel run //hello_world
+        INFO: Found 1 target...
+        Target //examples/rust/hello_world:hello_world up-to-date:
+        bazel-bin/examples/rust/hello_world/hello_world
+        INFO: Elapsed time: 1.308s, Critical Path: 1.22s
+
+        INFO: Running command line: bazel-bin/examples/rust/hello_world/hello_world
+        Hello world
+        ```
+
+        On Windows, a PDB file containing debugging information is available under
+        the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
+        is available under the key `dsym_folder` in `OutputGroupInfo`.
+"""),
+)
+
+rust_test = rule(
+    implementation = _rust_test_impl,
+    provides = _common_providers,
+    attrs = dict(_common_attrs.items() +
+                 _rust_test_attrs.items()),
+    executable = True,
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    test = True,
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Builds a Rust test crate.
+
+        Examples:
+
+        Suppose you have the following directory structure for a Rust library crate \
+        with unit test code in the library sources:
+
+        ```output
+        [workspace]/
+            WORKSPACE
+            hello_lib/
+                BUILD
+                src/
+                    lib.rs
+        ```
+
+        `hello_lib/src/lib.rs`:
+        ```rust
+        pub struct Greeter {
+            greeting: String,
+        }
+
+        impl Greeter {
+            pub fn new(greeting: &str) -> Greeter {
+                Greeter { greeting: greeting.to_string(), }
+            }
+
+            pub fn greet(&self, thing: &str) -> String {
+                format!("{} {}", &self.greeting, thing)
+            }
+        }
+
+        #[cfg(test)]
+        mod test {
+            use super::Greeter;
+
+            #[test]
+            fn test_greeting() {
+                let hello = Greeter::new("Hi");
+                assert_eq!("Hi Rust", hello.greet("Rust"));
+            }
+        }
+        ```
+
+        To build and run the tests, simply add a `rust_test` rule with no `srcs` and \
+        only depends on the `hello_lib` `rust_library` target:
+
+        `hello_lib/BUILD`:
+        ```python
+        load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+        rust_library(
+            name = "hello_lib",
+            srcs = ["src/lib.rs"],
+        )
+
+        rust_test(
+            name = "hello_lib_test",
+            deps = [":hello_lib"],
+        )
+        ```
+
+        Run the test with `bazel build //hello_lib:hello_lib_test`.
+
+        To run a crate or lib with the `#[cfg(test)]` configuration, handling inline \
+        tests, you should specify the crate directly like so.
+
+        ```python
+        rust_test(
+            name = "hello_lib_test",
+            crate = ":hello_lib",
+            # You may add other deps that are specific to the test configuration
+            deps = ["//some/dev/dep"],
+        )
+        ```
+
+        ### Example: `test` directory
+
+        Integration tests that live in the [`tests` directory][int-tests], they are \
+        essentially built as separate crates. Suppose you have the following directory \
+        structure where `greeting.rs` is an integration test for the `hello_lib` \
+        library crate:
+
+        [int-tests]: http://doc.rust-lang.org/book/testing.html#the-tests-directory
+
+        ```output
+        [workspace]/
+            WORKSPACE
+            hello_lib/
+                BUILD
+                src/
+                    lib.rs
+                tests/
+                    greeting.rs
+        ```
+
+        `hello_lib/tests/greeting.rs`:
+        ```rust
+        extern crate hello_lib;
+
+        use hello_lib;
+
+        #[test]
+        fn test_greeting() {
+            let hello = greeter::Greeter::new("Hello");
+            assert_eq!("Hello world", hello.greeting("world"));
+        }
+        ```
+
+        To build the `greeting.rs` integration test, simply add a `rust_test` target
+        with `greeting.rs` in `srcs` and a dependency on the `hello_lib` target:
+
+        `hello_lib/BUILD`:
+        ```python
+        load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+        rust_library(
+            name = "hello_lib",
+            srcs = ["src/lib.rs"],
+        )
+
+        rust_test(
+            name = "greeting_test",
+            srcs = ["tests/greeting.rs"],
+            deps = [":hello_lib"],
+        )
+        ```
+
+        Run the test with `bazel build //hello_lib:hello_lib_test`.
+"""),
+)
+
+def rust_test_suite(name, srcs, **kwargs):
+    """A rule for creating a test suite for a set of `rust_test` targets.
+
+    This rule can be used for setting up typical rust [integration tests][it]. Given the following
+    directory structure:
+
+    ```text
+    [crate]/
+        BUILD.bazel
+        src/
+            lib.rs
+            main.rs
+        tests/
+            integrated_test_a.rs
+            integrated_test_b.rs
+            integrated_test_c.rs
+            patterns/
+                fibonacci_test.rs
+    ```
+
+    The rule can be used to generate [rust_test](#rust_test) targets for each source file under `tests`
+    and a [test_suite][ts] which encapsulates all tests.
+
+    ```python
+    load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test_suite")
+
+    rust_library(
+        name = "math_lib",
+        srcs = ["src/lib.rs"],
+    )
+
+    rust_binary(
+        name = "math_bin",
+        srcs = ["src/main.rs"],
+    )
+
+    rust_test_suite(
+        name = "integrated_tests_suite",
+        srcs = glob(["tests/**"]),
+        deps = [":math_lib"],
+    )
+    ```
+
+    [it]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
+    [ts]: https://docs.bazel.build/versions/master/be/general.html#test_suite
+
+    Args:
+        name (str): The name of the `test_suite`.
+        srcs (list): All test sources, typically `glob(["tests/**/*.rs"])`.
+        **kwargs (dict): Additional keyword arguments for the underyling [rust_test](#rust_test) targets. The
+            `tags` argument is also passed to the generated `test_suite` target.
+    """
+    tests = []
+
+    for src in srcs:
+        if not src.endswith(".rs"):
+            fail("srcs should have `.rs` extensions")
+
+        # Prefixed with `name` to allow parameterization with macros
+        # The test name should not end with `.rs`
+        test_name = name + "_" + src[:-3]
+        rust_test(
+            name = test_name,
+            crate_name = test_name.replace("/", "_"),
+            srcs = [src],
+            **kwargs
+        )
+        tests.append(test_name)
+
+    native.test_suite(
+        name = name,
+        tests = tests,
+        tags = kwargs.get("tags", None),
+    )
diff --git a/third_party/rules_rust/rust/private/rust_analyzer.bzl b/third_party/rules_rust/rust/private/rust_analyzer.bzl
new file mode 100644
index 0000000..e28ca30
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rust_analyzer.bzl
@@ -0,0 +1,240 @@
+# Copyright 2020 Google
+#
+# 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.
+
+"""
+Rust Analyzer Bazel rules.
+
+rust_analyzer will generate a rust-project.json file for the
+given targets. This file can be consumed by rust-analyzer as an alternative
+to Cargo.toml files.
+"""
+
+load("//rust/platform:triple_mappings.bzl", "system_to_dylib_ext", "triple_to_system")
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:rustc.bzl", "BuildInfo")
+load("//rust/private:utils.bzl", "dedent", "find_toolchain")
+
+RustAnalyzerInfo = provider(
+    doc = "RustAnalyzerInfo holds rust crate metadata for targets",
+    fields = {
+        "build_info": "BuildInfo: build info for this crate if present",
+        "cfgs": "List[String]: features or other compilation --cfg settings",
+        "crate": "rust_common.crate_info",
+        "crate_specs": "Depset[File]: transitive closure of OutputGroupInfo files",
+        "deps": "List[RustAnalyzerInfo]: direct dependencies",
+        "env": "Dict{String: String}: Environment variables, used for the `env!` macro",
+        "proc_macro_dylib_path": "File: compiled shared library output of proc-macro rule",
+    },
+)
+
+def _rust_analyzer_aspect_impl(target, ctx):
+    if rust_common.crate_info not in target:
+        return []
+
+    toolchain = find_toolchain(ctx)
+
+    # Always add `test` & `debug_assertions`. See rust-analyzer source code:
+    # https://github.com/rust-analyzer/rust-analyzer/blob/2021-11-15/crates/project_model/src/workspace.rs#L529-L531
+    cfgs = ["test", "debug_assertions"]
+    if hasattr(ctx.rule.attr, "crate_features"):
+        cfgs += ['feature="{}"'.format(f) for f in ctx.rule.attr.crate_features]
+    if hasattr(ctx.rule.attr, "rustc_flags"):
+        cfgs += [f[6:] for f in ctx.rule.attr.rustc_flags if f.startswith("--cfg ") or f.startswith("--cfg=")]
+
+    # Save BuildInfo if we find any (for build script output)
+    build_info = None
+    for dep in ctx.rule.attr.deps:
+        if BuildInfo in dep:
+            build_info = dep[BuildInfo]
+
+    dep_infos = [dep[RustAnalyzerInfo] for dep in ctx.rule.attr.deps if RustAnalyzerInfo in dep]
+    if hasattr(ctx.rule.attr, "proc_macro_deps"):
+        dep_infos += [dep[RustAnalyzerInfo] for dep in ctx.rule.attr.proc_macro_deps if RustAnalyzerInfo in dep]
+    if hasattr(ctx.rule.attr, "crate") and ctx.rule.attr.crate != None:
+        dep_infos.append(ctx.rule.attr.crate[RustAnalyzerInfo])
+
+    crate_spec = ctx.actions.declare_file(ctx.label.name + ".rust_analyzer_crate_spec")
+
+    crate_info = target[rust_common.crate_info]
+
+    rust_analyzer_info = RustAnalyzerInfo(
+        crate = crate_info,
+        cfgs = cfgs,
+        env = getattr(ctx.rule.attr, "rustc_env", {}),
+        deps = dep_infos,
+        crate_specs = depset(direct = [crate_spec], transitive = [dep.crate_specs for dep in dep_infos]),
+        proc_macro_dylib_path = find_proc_macro_dylib_path(toolchain, target),
+        build_info = build_info,
+    )
+
+    ctx.actions.write(
+        output = crate_spec,
+        content = json.encode(_create_single_crate(ctx, rust_analyzer_info)),
+    )
+
+    return [
+        rust_analyzer_info,
+        OutputGroupInfo(rust_analyzer_crate_spec = rust_analyzer_info.crate_specs),
+    ]
+
+def find_proc_macro_dylib_path(toolchain, target):
+    """Find the proc_macro_dylib_path of target. Returns None if target crate is not type proc-macro.
+
+    Args:
+        toolchain: The current rust toolchain.
+        target: The current target.
+    Returns:
+        (path): The path to the proc macro dylib, or None if this crate is not a proc-macro.
+    """
+    if target[rust_common.crate_info].type != "proc-macro":
+        return None
+
+    dylib_ext = system_to_dylib_ext(triple_to_system(toolchain.target_triple))
+    for action in target.actions:
+        for output in action.outputs.to_list():
+            if output.extension == dylib_ext[1:]:
+                return output.path
+
+    # Failed to find the dylib path inside a proc-macro crate.
+    # TODO: Should this be an error?
+    return None
+
+rust_analyzer_aspect = aspect(
+    attr_aspects = ["deps", "proc_macro_deps", "crate"],
+    implementation = _rust_analyzer_aspect_impl,
+    toolchains = [str(Label("//rust:toolchain"))],
+    incompatible_use_toolchain_transition = True,
+    doc = "Annotates rust rules with RustAnalyzerInfo later used to build a rust-project.json",
+)
+
+_exec_root_tmpl = "__EXEC_ROOT__/"
+
+def _crate_id(crate_info):
+    """Returns a unique stable identifier for a crate
+
+    Returns:
+        (string): This crate's unique stable id.
+    """
+    return "ID-" + crate_info.root.path
+
+def _create_single_crate(ctx, info):
+    """Creates a crate in the rust-project.json format.
+
+    Args:
+        ctx (ctx): The rule context
+        info (RustAnalyzerInfo): RustAnalyzerInfo for the current crate
+
+    Returns:
+        (dict) The crate rust-project.json representation
+    """
+    crate_name = info.crate.name
+    crate = dict()
+    crate_id = _crate_id(info.crate)
+    crate["crate_id"] = crate_id
+    crate["display_name"] = crate_name
+    crate["edition"] = info.crate.edition
+    crate["env"] = {}
+    crate["crate_type"] = info.crate.type
+
+    # Switch on external/ to determine if crates are in the workspace or remote.
+    # TODO: Some folks may want to override this for vendored dependencies.
+    root_path = info.crate.root.path
+    root_dirname = info.crate.root.dirname
+    if root_path.startswith("external/"):
+        crate["is_workspace_member"] = False
+        crate["root_module"] = _exec_root_tmpl + root_path
+        crate_root = _exec_root_tmpl + root_dirname
+    else:
+        crate["is_workspace_member"] = True
+        crate["root_module"] = root_path
+        crate_root = root_dirname
+
+    if info.build_info != None:
+        out_dir_path = info.build_info.out_dir.path
+        crate["env"].update({"OUT_DIR": _exec_root_tmpl + out_dir_path})
+        crate["source"] = {
+            # We have to tell rust-analyzer about our out_dir since it's not under the crate root.
+            "exclude_dirs": [],
+            "include_dirs": [crate_root, _exec_root_tmpl + out_dir_path],
+        }
+
+    # TODO: The only imagined use case is an env var holding a filename in the workspace passed to a
+    # macro like include_bytes!. Other use cases might exist that require more complex logic.
+    expand_targets = getattr(ctx.rule.attr, "data", []) + getattr(ctx.rule.attr, "compile_data", [])
+    crate["env"].update({k: ctx.expand_location(v, expand_targets) for k, v in info.env.items()})
+
+    # Omit when a crate appears to depend on itself (e.g. foo_test crates).
+    # It can happen a single source file is present in multiple crates - there can
+    # be a `rust_library` with a `lib.rs` file, and a `rust_test` for the `test`
+    # module in that file. Tests can declare more dependencies than what library
+    # had. Therefore we had to collect all RustAnalyzerInfos for a given crate
+    # and take deps from all of them.
+
+    # There's one exception - if the dependency is the same crate name as the
+    # the crate being processed, we don't add it as a dependency to itself. This is
+    # common and expected - `rust_test.crate` pointing to the `rust_library`.
+    crate["deps"] = [_crate_id(dep.crate) for dep in info.deps if _crate_id(dep.crate) != crate_id]
+    crate["cfg"] = info.cfgs
+    crate["target"] = find_toolchain(ctx).target_triple
+    if info.proc_macro_dylib_path != None:
+        crate["proc_macro_dylib_path"] = _exec_root_tmpl + info.proc_macro_dylib_path
+    return crate
+
+def _rust_analyzer_detect_sysroot_impl(ctx):
+    rust_toolchain = find_toolchain(ctx)
+
+    if not rust_toolchain.rustc_srcs:
+        fail(
+            "Current Rust toolchain doesn't contain rustc sources in `rustc_srcs` attribute.",
+            "These are needed by rust analyzer.",
+            "If you are using the default Rust toolchain, add `rust_repositories(include_rustc_srcs = True, ...).` to your WORKSPACE file.",
+        )
+    sysroot_src = rust_toolchain.rustc_srcs.label.package + "/library"
+    if rust_toolchain.rustc_srcs.label.workspace_root:
+        sysroot_src = _exec_root_tmpl + rust_toolchain.rustc_srcs.label.workspace_root + "/" + sysroot_src
+
+    sysroot_src_file = ctx.actions.declare_file(ctx.label.name + ".rust_analyzer_sysroot_src")
+    ctx.actions.write(
+        output = sysroot_src_file,
+        content = sysroot_src,
+    )
+
+    return [DefaultInfo(files = depset([sysroot_src_file]))]
+
+rust_analyzer_detect_sysroot = rule(
+    implementation = _rust_analyzer_detect_sysroot_impl,
+    toolchains = ["@rules_rust//rust:toolchain"],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Detect the sysroot and store in a file for use by the gen_rust_project tool.
+    """),
+)
+
+def _rust_analyzer_impl(_ctx):
+    pass
+
+rust_analyzer = rule(
+    attrs = {
+        "targets": attr.label_list(
+            aspects = [rust_analyzer_aspect],
+            doc = "List of all targets to be included in the index",
+        ),
+    },
+    implementation = _rust_analyzer_impl,
+    toolchains = [str(Label("//rust:toolchain"))],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Deprecated: gen_rust_project can now create a rust-project.json without a rust_analyzer rule.
+    """),
+)
diff --git a/third_party/rules_rust/rust/private/rustc.bzl b/third_party/rules_rust/rust/private/rustc.bzl
new file mode 100644
index 0000000..596c10d
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rustc.bzl
@@ -0,0 +1,1436 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Functionality for constructing actions that invoke the Rust compiler"""
+
+load(
+    "@bazel_tools//tools/build_defs/cc:action_names.bzl",
+    "CPP_LINK_EXECUTABLE_ACTION_NAME",
+)
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:providers.bzl", _BuildInfo = "BuildInfo")
+load("//rust/private:stamp.bzl", "is_stamping_enabled")
+load(
+    "//rust/private:utils.bzl",
+    "abs",
+    "expand_dict_value_locations",
+    "expand_list_element_locations",
+    "find_cc_toolchain",
+    "get_lib_name",
+    "get_preferred_artifact",
+    "is_exec_configuration",
+    "make_static_lib_symlink",
+    "relativize",
+)
+
+BuildInfo = _BuildInfo
+
+AliasableDepInfo = provider(
+    doc = "A provider mapping an alias name to a Crate's information.",
+    fields = {
+        "dep": "CrateInfo",
+        "name": "str",
+    },
+)
+
+_error_format_values = ["human", "json", "short"]
+
+ErrorFormatInfo = provider(
+    doc = "Set the --error-format flag for all rustc invocations",
+    fields = {"error_format": "(string) [" + ", ".join(_error_format_values) + "]"},
+)
+
+ExtraRustcFlagsInfo = provider(
+    doc = "Pass each value as an additional flag to non-exec rustc invocations",
+    fields = {"extra_rustc_flags": "List[string] Extra flags to pass to rustc in non-exec configuration"},
+)
+
+ExtraExecRustcFlagsInfo = provider(
+    doc = "Pass each value as an additional flag to exec rustc invocations",
+    fields = {"extra_exec_rustc_flags": "List[string] Extra flags to pass to rustc in exec configuration"},
+)
+
+def _get_rustc_env(attr, toolchain, crate_name):
+    """Gathers rustc environment variables
+
+    Args:
+        attr (struct): The current target's attributes
+        toolchain (rust_toolchain): The current target's rust toolchain context
+        crate_name (str): The name of the crate to be compiled
+
+    Returns:
+        dict: Rustc environment variables
+    """
+    version = attr.version if hasattr(attr, "version") else "0.0.0"
+    major, minor, patch = version.split(".", 2)
+    if "-" in patch:
+        patch, pre = patch.split("-", 1)
+    else:
+        pre = ""
+    return {
+        "CARGO_CFG_TARGET_ARCH": toolchain.target_arch,
+        "CARGO_CFG_TARGET_OS": toolchain.os,
+        "CARGO_CRATE_NAME": crate_name,
+        "CARGO_PKG_AUTHORS": "",
+        "CARGO_PKG_DESCRIPTION": "",
+        "CARGO_PKG_HOMEPAGE": "",
+        "CARGO_PKG_NAME": attr.name,
+        "CARGO_PKG_VERSION": version,
+        "CARGO_PKG_VERSION_MAJOR": major,
+        "CARGO_PKG_VERSION_MINOR": minor,
+        "CARGO_PKG_VERSION_PATCH": patch,
+        "CARGO_PKG_VERSION_PRE": pre,
+    }
+
+def get_compilation_mode_opts(ctx, toolchain):
+    """Gathers rustc flags for the current compilation mode (opt/debug)
+
+    Args:
+        ctx (ctx): The current rule's context object
+        toolchain (rust_toolchain): The current rule's `rust_toolchain`
+
+    Returns:
+        struct: See `_rust_toolchain_impl` for more details
+    """
+    comp_mode = ctx.var["COMPILATION_MODE"]
+    if not comp_mode in toolchain.compilation_mode_opts:
+        fail("Unrecognized compilation mode {} for toolchain.".format(comp_mode))
+
+    return toolchain.compilation_mode_opts[comp_mode]
+
+def _are_linkstamps_supported(feature_configuration, has_grep_includes):
+    # Are linkstamps supported by the C++ toolchain?
+    return (cc_common.is_enabled(feature_configuration = feature_configuration, feature_name = "linkstamps") and
+            # Is Bazel recent enough to support Starlark linkstamps?
+            hasattr(cc_common, "register_linkstamp_compile_action") and
+            # The current rule doesn't define _grep_includes attribute; this
+            # attribute is required for compiling linkstamps.
+            has_grep_includes)
+
+def _should_use_pic(cc_toolchain, feature_configuration, crate_type):
+    if crate_type in ("cdylib" or "dylib"):
+        return cc_toolchain.needs_pic_for_dynamic_libraries(feature_configuration = feature_configuration)
+    return False
+
+def collect_deps(
+        deps,
+        proc_macro_deps,
+        aliases,
+        are_linkstamps_supported = False):
+    """Walks through dependencies and collects the transitive dependencies.
+
+    Args:
+        deps (list): The deps from ctx.attr.deps.
+        proc_macro_deps (list): The proc_macro deps from ctx.attr.proc_macro_deps.
+        aliases (dict): A dict mapping aliased targets to their actual Crate information.
+        are_linkstamps_supported (bool): Whether the current rule and the toolchain support building linkstamps..
+
+    Returns:
+        tuple: Returns a tuple of:
+            DepInfo,
+            BuildInfo,
+            linkstamps (depset[CcLinkstamp]): A depset of CcLinkstamps that need to be compiled and linked into all linked binaries.
+
+    """
+    direct_crates = []
+    transitive_crates = []
+    transitive_noncrates = []
+    transitive_build_infos = []
+    transitive_link_search_paths = []
+    build_info = None
+    linkstamps = []
+    transitive_crate_outputs = []
+
+    aliases = {k.label: v for k, v in aliases.items()}
+    for dep in depset(transitive = [deps, proc_macro_deps]).to_list():
+        (crate_info, dep_info) = _get_crate_and_dep_info(dep)
+        cc_info = _get_cc_info(dep)
+        dep_build_info = _get_build_info(dep)
+
+        if cc_info and are_linkstamps_supported:
+            linkstamps.append(cc_info.linking_context.linkstamps())
+
+        if crate_info:
+            # This dependency is a rust_library
+
+            # When crate_info.owner is set, we use it. When the dep type is Target we get the
+            # label from dep.label
+            owner = getattr(crate_info, "owner", dep.label if type(dep) == "Target" else None)
+
+            direct_crates.append(AliasableDepInfo(
+                name = aliases.get(owner, crate_info.name),
+                dep = crate_info,
+            ))
+
+            transitive_crates.append(depset([crate_info], transitive = [dep_info.transitive_crates]))
+            transitive_crate_outputs.append(
+                depset(
+                    [crate_info.output],
+                    transitive = [dep_info.transitive_crate_outputs],
+                ),
+            )
+            transitive_noncrates.append(dep_info.transitive_noncrates)
+            transitive_build_infos.append(dep_info.transitive_build_infos)
+            transitive_link_search_paths.append(dep_info.link_search_path_files)
+
+        elif cc_info:
+            # This dependency is a cc_library
+            transitive_noncrates.append(cc_info.linking_context.linker_inputs)
+        elif dep_build_info:
+            if build_info:
+                fail("Several deps are providing build information, " +
+                     "only one is allowed in the dependencies")
+            build_info = dep_build_info
+            transitive_build_infos.append(depset([build_info]))
+            transitive_link_search_paths.append(depset([build_info.link_search_paths]))
+        else:
+            fail("rust targets can only depend on rust_library, rust_*_library or cc_library " +
+                 "targets.")
+
+    transitive_crates_depset = depset(transitive = transitive_crates)
+
+    return (
+        rust_common.dep_info(
+            direct_crates = depset(direct_crates),
+            transitive_crates = transitive_crates_depset,
+            transitive_noncrates = depset(
+                transitive = transitive_noncrates,
+                order = "topological",  # dylib link flag ordering matters.
+            ),
+            transitive_crate_outputs = depset(transitive = transitive_crate_outputs),
+            transitive_build_infos = depset(transitive = transitive_build_infos),
+            link_search_path_files = depset(transitive = transitive_link_search_paths),
+            dep_env = build_info.dep_env if build_info else None,
+        ),
+        build_info,
+        depset(transitive = linkstamps),
+    )
+
+def _collect_libs_from_linker_inputs(linker_inputs, use_pic):
+    # TODO: We could let the user choose how to link, instead of always preferring to link static libraries.
+    return [
+        get_preferred_artifact(lib, use_pic)
+        for li in linker_inputs
+        for lib in li.libraries
+    ]
+
+def _get_crate_and_dep_info(dep):
+    if type(dep) == "Target" and rust_common.crate_info in dep:
+        return (dep[rust_common.crate_info], dep[rust_common.dep_info])
+    elif type(dep) == "struct" and hasattr(dep, "crate_info"):
+        return (dep.crate_info, dep.dep_info)
+    return (None, None)
+
+def _get_cc_info(dep):
+    if type(dep) == "Target" and CcInfo in dep:
+        return dep[CcInfo]
+    elif type(dep) == "struct" and hasattr(dep, "cc_info"):
+        return dep.cc_info
+    return None
+
+def _get_build_info(dep):
+    if type(dep) == "Target" and BuildInfo in dep:
+        return dep[BuildInfo]
+    elif type(dep) == "struct" and hasattr(dep, "build_info"):
+        return dep.build_info
+    return None
+
+def get_cc_user_link_flags(ctx):
+    """Get the current target's linkopt flags
+
+    Args:
+        ctx (ctx): The current rule's context object
+
+    Returns:
+        depset: The flags passed to Bazel by --linkopt option.
+    """
+    return ctx.fragments.cpp.linkopts
+
+def get_linker_and_args(ctx, attr, cc_toolchain, feature_configuration, rpaths):
+    """Gathers cc_common linker information
+
+    Args:
+        ctx (ctx): The current target's context object
+        attr (struct): Attributes to use in gathering linker args
+        cc_toolchain (CcToolchain): cc_toolchain for which we are creating build variables.
+        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
+        rpaths (depset): Depset of directories where loader will look for libraries at runtime.
+
+
+    Returns:
+        tuple: A tuple of the following items:
+            - (str): The tool path for given action.
+            - (sequence): A flattened command line flags for given action.
+            - (dict): Environment variables to be set for given action.
+    """
+    user_link_flags = get_cc_user_link_flags(ctx)
+
+    # Add linkopt's from dependencies. This includes linkopts from transitive
+    # dependencies since they get merged up.
+    for dep in getattr(attr, "deps", []):
+        if CcInfo in dep and dep[CcInfo].linking_context:
+            for linker_input in dep[CcInfo].linking_context.linker_inputs.to_list():
+                for flag in linker_input.user_link_flags:
+                    user_link_flags.append(flag)
+    link_variables = cc_common.create_link_variables(
+        feature_configuration = feature_configuration,
+        cc_toolchain = cc_toolchain,
+        is_linking_dynamic_library = False,
+        runtime_library_search_directories = rpaths,
+        user_link_flags = user_link_flags,
+    )
+    link_args = cc_common.get_memory_inefficient_command_line(
+        feature_configuration = feature_configuration,
+        action_name = CPP_LINK_EXECUTABLE_ACTION_NAME,
+        variables = link_variables,
+    )
+    link_env = cc_common.get_environment_variables(
+        feature_configuration = feature_configuration,
+        action_name = CPP_LINK_EXECUTABLE_ACTION_NAME,
+        variables = link_variables,
+    )
+    ld = cc_common.get_tool_for_action(
+        feature_configuration = feature_configuration,
+        action_name = CPP_LINK_EXECUTABLE_ACTION_NAME,
+    )
+
+    return ld, link_args, link_env
+
+def _process_build_scripts(
+        build_info,
+        dep_info,
+        compile_inputs):
+    """Gathers the outputs from a target's `cargo_build_script` action.
+
+    Args:
+        build_info (BuildInfo): The target Build's dependency info.
+        dep_info (DepInfo): The Depinfo provider form the target Crate's set of inputs.
+        compile_inputs (depset): A set of all files that will participate in the build.
+
+    Returns:
+        tuple: A tuple: A tuple of the following items:
+            - (depset[File]): A list of all build info `OUT_DIR` File objects
+            - (str): The `OUT_DIR` of the current build info
+            - (File): An optional path to a generated environment file from a `cargo_build_script` target
+            - (depset[File]): All direct and transitive build flags from the current build info.
+    """
+    extra_inputs, out_dir, build_env_file, build_flags_files = _create_extra_input_args(build_info, dep_info)
+    compile_inputs = depset(transitive = [extra_inputs, compile_inputs])
+    return compile_inputs, out_dir, build_env_file, build_flags_files
+
+def _symlink_for_ambiguous_lib(actions, toolchain, crate_info, lib):
+    """Constructs a disambiguating symlink for a library dependency.
+
+    Args:
+      actions (Actions): The rule's context actions object.
+      toolchain: The Rust toolchain object.
+      crate_info (CrateInfo): The target crate's info.
+      lib (File): The library to symlink to.
+
+    Returns:
+      (File): The disambiguating symlink for the library.
+    """
+    # FIXME: Once the relative order part of the native-link-modifiers rustc
+    # feature is stable, we should be able to eliminate the need to construct
+    # symlinks by passing the full paths to the libraries.
+    # https://github.com/rust-lang/rust/issues/81490.
+
+    # Take the absolute value of hash() since it could be negative.
+    path_hash = abs(hash(lib.path))
+    lib_name = get_lib_name(lib)
+
+    prefix = "lib"
+    extension = ".a"
+    if toolchain.os.startswith("windows"):
+        prefix = ""
+        extension = ".lib"
+
+    # Ensure the symlink follows the lib<name>.a pattern on Unix-like platforms
+    # or <name>.lib on Windows.
+    # Add a hash of the original library path to disambiguate libraries with the same basename.
+    symlink_name = "{}{}-{}{}".format(prefix, lib_name, path_hash, extension)
+
+    # Add the symlink to a target crate-specific _ambiguous_libs/ subfolder,
+    # to avoid possible collisions with sibling crates that may depend on the
+    # same ambiguous libraries.
+    symlink = actions.declare_file("_ambiguous_libs/" + crate_info.output.basename + "/" + symlink_name)
+    actions.symlink(
+        output = symlink,
+        target_file = lib,
+        progress_message = "Creating symlink to ambiguous lib: {}".format(lib.path),
+    )
+    return symlink
+
+def _disambiguate_libs(actions, toolchain, crate_info, dep_info, use_pic):
+    """Constructs disambiguating symlinks for ambiguous library dependencies.
+
+    The symlinks are all created in a _ambiguous_libs/ subfolder specific to
+    the target crate to avoid possible collisions with sibling crates that may
+    depend on the same ambiguous libraries.
+
+    Args:
+      actions (Actions): The rule's context actions object.
+      toolchain: The Rust toolchain object.
+      crate_info (CrateInfo): The target crate's info.
+      dep_info: (DepInfo): The target crate's dependency info.
+      use_pic: (boolean): Whether the build should use PIC.
+
+    Returns:
+      dict[String, File]: A mapping from ambiguous library paths to their
+        disambiguating symlink.
+    """
+    # FIXME: Once the relative order part of the native-link-modifiers rustc
+    # feature is stable, we should be able to eliminate the need to construct
+    # symlinks by passing the full paths to the libraries.
+    # https://github.com/rust-lang/rust/issues/81490.
+
+    # A dictionary from file paths of ambiguous libraries to the corresponding
+    # symlink.
+    ambiguous_libs = {}
+
+    # A dictionary maintaining a mapping from preferred library name to the
+    # last visited artifact with that name.
+    visited_libs = {}
+    for link_input in dep_info.transitive_noncrates.to_list():
+        for lib in link_input.libraries:
+            # FIXME: Dynamic libs are not disambiguated right now, there are
+            # cases where those have a non-standard name with version (e.g.,
+            # //test/unit/versioned_libs). We hope that the link modifiers
+            # stabilization will come before we need to make this work.
+            if _is_dylib(lib):
+                continue
+            artifact = get_preferred_artifact(lib, use_pic)
+            name = get_lib_name(artifact)
+
+            # On Linux-like platforms, normally library base names start with
+            # `lib`, following the pattern `lib[name].(a|lo)` and we pass
+            # -lstatic=name.
+            # On Windows, the base name looks like `name.lib` and we pass
+            # -lstatic=name.
+            # FIXME: Under the native-link-modifiers unstable rustc feature,
+            # we could use -lstatic:+verbatim instead.
+            needs_symlink_to_standardize_name = (
+                (toolchain.os.startswith("linux") or toolchain.os.startswith("mac") or toolchain.os.startswith("darwin")) and
+                artifact.basename.endswith(".a") and not artifact.basename.startswith("lib")
+            ) or (
+                toolchain.os.startswith("windows") and not artifact.basename.endswith(".lib")
+            )
+
+            # Detect cases where we need to disambiguate library dependencies
+            # by constructing symlinks.
+            if (
+                needs_symlink_to_standardize_name or
+                # We have multiple libraries with the same name.
+                (name in visited_libs and visited_libs[name].path != artifact.path)
+            ):
+                # Disambiguate the previously visited library (if we just detected
+                # that it is ambiguous) and the current library.
+                if name in visited_libs:
+                    old_path = visited_libs[name].path
+                    if old_path not in ambiguous_libs:
+                        ambiguous_libs[old_path] = _symlink_for_ambiguous_lib(actions, toolchain, crate_info, visited_libs[name])
+                ambiguous_libs[artifact.path] = _symlink_for_ambiguous_lib(actions, toolchain, crate_info, artifact)
+
+            visited_libs[name] = artifact
+    return ambiguous_libs
+
+def collect_inputs(
+        ctx,
+        file,
+        files,
+        linkstamps,
+        toolchain,
+        cc_toolchain,
+        feature_configuration,
+        crate_info,
+        dep_info,
+        build_info,
+        stamp = False):
+    """Gather's the inputs and required input information for a rustc action
+
+    Args:
+        ctx (ctx): The rule's context object.
+        file (struct): A struct containing files defined in label type attributes marked as `allow_single_file`.
+        files (list): A list of all inputs (`ctx.files`).
+        linkstamps (depset): A depset of CcLinkstamps that need to be compiled and linked into all linked binaries.
+        toolchain (rust_toolchain): The current `rust_toolchain`.
+        cc_toolchain (CcToolchainInfo): The current `cc_toolchain`.
+        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
+        crate_info (CrateInfo): The Crate information of the crate to process build scripts for.
+        dep_info (DepInfo): The target Crate's dependency information.
+        build_info (BuildInfo): The target Crate's build settings.
+        stamp (bool, optional): Whether or not workspace status stamping is enabled. For more details see
+            https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
+
+    Returns:
+        tuple: A tuple: A tuple of the following items:
+            - (list): A list of all build info `OUT_DIR` File objects
+            - (str): The `OUT_DIR` of the current build info
+            - (File): An optional path to a generated environment file from a `cargo_build_script` target
+            - (depset[File]): All direct and transitive build flag files from the current build info
+            - (list[File]): Linkstamp outputs
+            - (dict[String, File]): Ambiguous libs, see `_disambiguate_libs`.
+    """
+    linker_script = getattr(file, "linker_script") if hasattr(file, "linker_script") else None
+
+    linker_depset = cc_toolchain.all_files
+
+    use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_info.type)
+
+    # Pass linker inputs only for linking-like actions, not for example where
+    # the output is rlib. This avoids quadratic behavior where transitive noncrates are
+    # flattened on each transitive rust_library dependency.
+    additional_transitive_inputs = []
+    ambiguous_libs = {}
+    if crate_info.type in ("staticlib", "proc-macro"):
+        additional_transitive_inputs = _collect_libs_from_linker_inputs(
+            dep_info.transitive_noncrates.to_list(),
+            use_pic,
+        )
+    elif crate_info.type in ("bin", "dylib", "cdylib"):
+        linker_inputs = dep_info.transitive_noncrates.to_list()
+        ambiguous_libs = _disambiguate_libs(ctx.actions, toolchain, crate_info, dep_info, use_pic)
+        additional_transitive_inputs = _collect_libs_from_linker_inputs(linker_inputs, use_pic) + [
+            additional_input
+            for linker_input in linker_inputs
+            for additional_input in linker_input.additional_inputs
+        ] + ambiguous_libs.values()
+
+    # Compute linkstamps. Use the inputs of the binary as inputs to the
+    # linkstamp action to ensure linkstamps are rebuilt whenever binary inputs
+    # change.
+    linkstamp_outs = []
+
+    nolinkstamp_compile_inputs = depset(
+        getattr(files, "data", []) +
+        ([build_info.rustc_env, build_info.flags] if build_info else []) +
+        ([toolchain.target_json] if toolchain.target_json else []) +
+        ([] if linker_script == None else [linker_script]),
+        transitive = [
+            linker_depset,
+            crate_info.srcs,
+            dep_info.transitive_crate_outputs,
+            depset(additional_transitive_inputs),
+            crate_info.compile_data,
+            toolchain.all_files,
+        ],
+    )
+
+    if crate_info.type in ("bin", "cdylib"):
+        # There is no other way to register an action for each member of a depset than
+        # flattening the depset as of 2021-10-12. Luckily, usually there is only one linkstamp
+        # in a build, and we only flatten the list on binary targets that perform transitive linking,
+        # so it's extremely unlikely that this call to `to_list()` will ever be a performance
+        # problem.
+        for linkstamp in linkstamps.to_list():
+            # The linkstamp output path is based on the binary crate
+            # name and the input linkstamp path. This is to disambiguate
+            # the linkstamp outputs produced by multiple binary crates
+            # that depend on the same linkstamp. We use the same pattern
+            # for the output name as the one used by native cc rules.
+            out_name = "_objs/" + crate_info.output.basename + "/" + linkstamp.file().path[:-len(linkstamp.file().extension)] + "o"
+            linkstamp_out = ctx.actions.declare_file(out_name)
+            linkstamp_outs.append(linkstamp_out)
+            cc_common.register_linkstamp_compile_action(
+                actions = ctx.actions,
+                cc_toolchain = cc_toolchain,
+                feature_configuration = feature_configuration,
+                grep_includes = ctx.file._grep_includes,
+                source_file = linkstamp.file(),
+                output_file = linkstamp_out,
+                compilation_inputs = linkstamp.hdrs(),
+                inputs_for_validation = nolinkstamp_compile_inputs,
+                label_replacement = str(ctx.label),
+                output_replacement = crate_info.output.path,
+            )
+
+    # If stamping is enabled include the volatile status info file
+    stamp_info = [ctx.version_file] if stamp else []
+
+    compile_inputs = depset(
+        linkstamp_outs + stamp_info,
+        transitive = [
+            nolinkstamp_compile_inputs,
+        ],
+    )
+
+    build_env_files = getattr(files, "rustc_env_files", [])
+    compile_inputs, out_dir, build_env_file, build_flags_files = _process_build_scripts(build_info, dep_info, compile_inputs)
+    if build_env_file:
+        build_env_files = [f for f in build_env_files] + [build_env_file]
+    compile_inputs = depset(build_env_files, transitive = [compile_inputs])
+
+    return compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs
+
+def construct_arguments(
+        ctx,
+        attr,
+        file,
+        toolchain,
+        tool_path,
+        cc_toolchain,
+        feature_configuration,
+        crate_info,
+        dep_info,
+        linkstamp_outs,
+        ambiguous_libs,
+        output_hash,
+        rust_flags,
+        out_dir,
+        build_env_files,
+        build_flags_files,
+        emit = ["dep-info", "link"],
+        force_all_deps_direct = False,
+        force_link = False,
+        stamp = False,
+        remap_path_prefix = "."):
+    """Builds an Args object containing common rustc flags
+
+    Args:
+        ctx (ctx): The rule's context object
+        attr (struct): The attributes for the target. These may be different from ctx.attr in an aspect context.
+        file (struct): A struct containing files defined in label type attributes marked as `allow_single_file`.
+        toolchain (rust_toolchain): The current target's `rust_toolchain`
+        tool_path (str): Path to rustc
+        cc_toolchain (CcToolchain): The CcToolchain for the current target.
+        feature_configuration (FeatureConfiguration): Class used to construct command lines from CROSSTOOL features.
+        crate_info (CrateInfo): The CrateInfo provider of the target crate
+        dep_info (DepInfo): The DepInfo provider of the target crate
+        linkstamp_outs (list): Linkstamp outputs of native dependencies
+        ambiguous_libs (dict): Ambiguous libs, see `_disambiguate_libs`
+        output_hash (str): The hashed path of the crate root
+        rust_flags (list): Additional flags to pass to rustc
+        out_dir (str): The path to the output directory for the target Crate.
+        build_env_files (list): Files containing rustc environment variables, for instance from `cargo_build_script` actions.
+        build_flags_files (depset): The output files of a `cargo_build_script` actions containing rustc build flags
+        emit (list): Values for the --emit flag to rustc.
+        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
+            to the commandline as opposed to -L.
+        force_link (bool, optional): Whether to add link flags to the command regardless of `emit`.
+        stamp (bool, optional): Whether or not workspace status stamping is enabled. For more details see
+            https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
+        remap_path_prefix (str, optional): A value used to remap `${pwd}` to. If set to a falsey value, no prefix will be set.
+
+    Returns:
+        tuple: A tuple of the following items
+            - (struct): A struct of arguments used to run the `Rustc` action
+                - process_wrapper_flags (Args): Arguments for the process wrapper
+                - rustc_path (Args): Arguments for invoking rustc via the process wrapper
+                - rustc_flags (Args): Rust flags for the Rust compiler
+                - all (list): A list of all `Args` objects in the order listed above.
+                    This is to be passed to the `arguments` parameter of actions
+            - (dict): Common rustc environment variables
+    """
+    output_dir = getattr(crate_info.output, "dirname", None)
+    linker_script = getattr(file, "linker_script", None)
+
+    env = _get_rustc_env(attr, toolchain, crate_info.name)
+
+    # Wrapper args first
+    process_wrapper_flags = ctx.actions.args()
+
+    for build_env_file in build_env_files:
+        process_wrapper_flags.add("--env-file", build_env_file)
+
+    process_wrapper_flags.add_all(build_flags_files, before_each = "--arg-file")
+
+    # Certain rust build processes expect to find files from the environment
+    # variable `$CARGO_MANIFEST_DIR`. Examples of this include pest, tera,
+    # asakuma.
+    #
+    # The compiler and by extension proc-macros see the current working
+    # directory as the Bazel exec root. This is what `$CARGO_MANIFEST_DIR`
+    # would default to but is often the wrong value (e.g. if the source is in a
+    # sub-package or if we are building something in an external repository).
+    # Hence, we need to set `CARGO_MANIFEST_DIR` explicitly.
+    #
+    # Since we cannot get the `exec_root` from starlark, we cheat a little and
+    # use `${pwd}` which resolves the `exec_root` at action execution time.
+    process_wrapper_flags.add("--subst", "pwd=${pwd}")
+
+    # If stamping is enabled, enable the functionality in the process wrapper
+    if stamp:
+        process_wrapper_flags.add("--volatile-status-file", ctx.version_file)
+
+    # Both ctx.label.workspace_root and ctx.label.package are relative paths
+    # and either can be empty strings. Avoid trailing/double slashes in the path.
+    components = "${{pwd}}/{}/{}".format(ctx.label.workspace_root, ctx.label.package).split("/")
+    env["CARGO_MANIFEST_DIR"] = "/".join([c for c in components if c])
+
+    if out_dir != None:
+        env["OUT_DIR"] = "${pwd}/" + out_dir
+
+    # Handle that the binary name and crate name may be different.
+    #
+    # If a target name contains a - then cargo (and rules_rust) will generate a
+    # crate name with _ instead.  Accordingly, rustc will generate a output
+    # file (executable, or rlib, or whatever) with _ not -.  But when cargo
+    # puts a binary in the target/${config} directory, and sets environment
+    # variables like `CARGO_BIN_EXE_${binary_name}` it will use the - version
+    # not the _ version.  So we rename the rustc-generated file (with _s) to
+    # have -s if needed.
+    emit_with_paths = emit
+    if crate_info.type == "bin" and crate_info.output != None:
+        generated_file = crate_info.name + toolchain.binary_ext
+        src = "/".join([crate_info.output.dirname, generated_file])
+        dst = crate_info.output.path
+        if src != dst:
+            emit_with_paths = [("link=" + dst if val == "link" else val) for val in emit]
+
+    # Arguments for launching rustc from the process wrapper
+    rustc_path = ctx.actions.args()
+    rustc_path.add("--")
+    rustc_path.add(tool_path)
+
+    # Rustc arguments
+    rustc_flags = ctx.actions.args()
+    rustc_flags.set_param_file_format("multiline")
+    rustc_flags.use_param_file("@%s", use_always = False)
+    rustc_flags.add(crate_info.root)
+    rustc_flags.add("--crate-name=" + crate_info.name)
+    rustc_flags.add("--crate-type=" + crate_info.type)
+    if hasattr(attr, "_error_format"):
+        rustc_flags.add("--error-format=" + attr._error_format[ErrorFormatInfo].error_format)
+
+    # Mangle symbols to disambiguate crates with the same name
+    extra_filename = "-" + output_hash if output_hash else ""
+    rustc_flags.add("--codegen=metadata=" + extra_filename)
+    if output_dir:
+        rustc_flags.add("--out-dir=" + output_dir)
+    rustc_flags.add("--codegen=extra-filename=" + extra_filename)
+
+    compilation_mode = get_compilation_mode_opts(ctx, toolchain)
+    rustc_flags.add("--codegen=opt-level=" + compilation_mode.opt_level)
+    rustc_flags.add("--codegen=debuginfo=" + compilation_mode.debug_info)
+
+    # For determinism to help with build distribution and such
+    if remap_path_prefix:
+        rustc_flags.add("--remap-path-prefix=${{pwd}}={}".format(remap_path_prefix))
+
+    if emit:
+        rustc_flags.add("--emit=" + ",".join(emit_with_paths))
+    rustc_flags.add("--color=always")
+    rustc_flags.add("--target=" + toolchain.target_flag_value)
+    if hasattr(attr, "crate_features"):
+        rustc_flags.add_all(getattr(attr, "crate_features"), before_each = "--cfg", format_each = 'feature="%s"')
+    if linker_script:
+        rustc_flags.add(linker_script.path, format = "--codegen=link-arg=-T%s")
+
+    # Gets the paths to the folders containing the standard library (or libcore)
+    rust_std_paths = toolchain.rust_std_paths.to_list()
+
+    # Tell Rustc where to find the standard library
+    rustc_flags.add_all(rust_std_paths, before_each = "-L", format_each = "%s")
+    rustc_flags.add_all(rust_flags)
+
+    # Deduplicate data paths due to https://github.com/bazelbuild/bazel/issues/14681
+    data_paths = depset(direct = getattr(attr, "data", []) + getattr(attr, "compile_data", [])).to_list()
+
+    rustc_flags.add_all(
+        expand_list_element_locations(
+            ctx,
+            getattr(attr, "rustc_flags", []),
+            data_paths,
+        ),
+    )
+    add_edition_flags(rustc_flags, crate_info)
+
+    # Link!
+    if ("link" in emit and crate_info.type not in ["rlib", "lib"]) or force_link:
+        # Rust's built-in linker can handle linking wasm files. We don't want to attempt to use the cc
+        # linker since it won't understand.
+        if toolchain.target_arch != "wasm32":
+            if output_dir:
+                use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_info.type)
+                rpaths = _compute_rpaths(toolchain, output_dir, dep_info, use_pic)
+            else:
+                rpaths = depset([])
+            ld, link_args, link_env = get_linker_and_args(ctx, attr, cc_toolchain, feature_configuration, rpaths)
+            env.update(link_env)
+            rustc_flags.add("--codegen=linker=" + ld)
+            rustc_flags.add_joined("--codegen", link_args, join_with = " ", format_joined = "link-args=%s")
+
+        _add_native_link_flags(rustc_flags, dep_info, linkstamp_outs, ambiguous_libs, crate_info.type, toolchain, cc_toolchain, feature_configuration)
+
+    # These always need to be added, even if not linking this crate.
+    add_crate_link_flags(rustc_flags, dep_info, force_all_deps_direct)
+
+    needs_extern_proc_macro_flag = "proc-macro" in [crate_info.type, crate_info.wrapped_crate_type] and \
+                                   crate_info.edition != "2015"
+    if needs_extern_proc_macro_flag:
+        rustc_flags.add("--extern")
+        rustc_flags.add("proc_macro")
+
+    # Make bin crate data deps available to tests.
+    for data in getattr(attr, "data", []):
+        if rust_common.crate_info in data:
+            dep_crate_info = data[rust_common.crate_info]
+            if dep_crate_info.type == "bin":
+                # Trying to make CARGO_BIN_EXE_{} canonical across platform by strip out extension if exists
+                env_basename = dep_crate_info.output.basename[:-(1 + len(dep_crate_info.output.extension))] if len(dep_crate_info.output.extension) > 0 else dep_crate_info.output.basename
+                env["CARGO_BIN_EXE_" + env_basename] = dep_crate_info.output.short_path
+
+    # Update environment with user provided variables.
+    env.update(expand_dict_value_locations(
+        ctx,
+        crate_info.rustc_env,
+        data_paths,
+    ))
+
+    # Ensure the sysroot is set for the target platform
+    env["SYSROOT"] = toolchain.sysroot
+
+    if toolchain._rename_first_party_crates:
+        env["RULES_RUST_THIRD_PARTY_DIR"] = toolchain._third_party_dir
+
+    # extra_rustc_flags apply to the target configuration, not the exec configuration.
+    if hasattr(ctx.attr, "_extra_rustc_flags") and not is_exec_configuration(ctx):
+        rustc_flags.add_all(ctx.attr._extra_rustc_flags[ExtraRustcFlagsInfo].extra_rustc_flags)
+
+    if hasattr(ctx.attr, "_extra_exec_rustc_flags") and is_exec_configuration(ctx):
+        rustc_flags.add_all(ctx.attr._extra_exec_rustc_flags[ExtraExecRustcFlagsInfo].extra_exec_rustc_flags)
+
+    # Create a struct which keeps the arguments separate so each may be tuned or
+    # replaced where necessary
+    args = struct(
+        process_wrapper_flags = process_wrapper_flags,
+        rustc_path = rustc_path,
+        rustc_flags = rustc_flags,
+        all = [process_wrapper_flags, rustc_path, rustc_flags],
+    )
+
+    return args, env
+
+def rustc_compile_action(
+        ctx,
+        attr,
+        toolchain,
+        crate_info,
+        output_hash = None,
+        rust_flags = [],
+        force_all_deps_direct = False):
+    """Create and run a rustc compile action based on the current rule's attributes
+
+    Args:
+        ctx (ctx): The rule's context object
+        attr (struct): Attributes to use for the rust compile action
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        crate_info (CrateInfo): The CrateInfo provider for the current target.
+        output_hash (str, optional): The hashed path of the crate root. Defaults to None.
+        rust_flags (list, optional): Additional flags to pass to rustc. Defaults to [].
+        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
+            to the commandline as opposed to -L.
+
+    Returns:
+        list: A list of the following providers:
+            - (CrateInfo): info for the crate we just built; same as `crate_info` parameter.
+            - (DepInfo): The transitive dependencies of this crate.
+            - (DefaultInfo): The output file for this crate, and its runfiles.
+    """
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+
+    dep_info, build_info, linkstamps = collect_deps(
+        deps = crate_info.deps,
+        proc_macro_deps = crate_info.proc_macro_deps,
+        aliases = crate_info.aliases,
+        are_linkstamps_supported = _are_linkstamps_supported(
+            feature_configuration = feature_configuration,
+            has_grep_includes = hasattr(ctx.attr, "_grep_includes"),
+        ),
+    )
+
+    # Determine if the build is currently running with --stamp
+    stamp = is_stamping_enabled(attr)
+
+    compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs = collect_inputs(
+        ctx = ctx,
+        file = ctx.file,
+        files = ctx.files,
+        linkstamps = linkstamps,
+        toolchain = toolchain,
+        cc_toolchain = cc_toolchain,
+        feature_configuration = feature_configuration,
+        crate_info = crate_info,
+        dep_info = dep_info,
+        build_info = build_info,
+        stamp = stamp,
+    )
+
+    args, env_from_args = construct_arguments(
+        ctx = ctx,
+        attr = attr,
+        file = ctx.file,
+        toolchain = toolchain,
+        tool_path = toolchain.rustc.path,
+        cc_toolchain = cc_toolchain,
+        feature_configuration = feature_configuration,
+        crate_info = crate_info,
+        dep_info = dep_info,
+        linkstamp_outs = linkstamp_outs,
+        ambiguous_libs = ambiguous_libs,
+        output_hash = output_hash,
+        rust_flags = rust_flags,
+        out_dir = out_dir,
+        build_env_files = build_env_files,
+        build_flags_files = build_flags_files,
+        force_all_deps_direct = force_all_deps_direct,
+        stamp = stamp,
+    )
+
+    env = dict(ctx.configuration.default_shell_env)
+    env.update(env_from_args)
+
+    if hasattr(attr, "version") and attr.version != "0.0.0":
+        formatted_version = " v{}".format(attr.version)
+    else:
+        formatted_version = ""
+
+    outputs = [crate_info.output]
+
+    # For a cdylib that might be added as a dependency to a cc_* target on Windows, it is important to include the
+    # interface library that rustc generates in the output files.
+    interface_library = None
+    if toolchain.os == "windows" and crate_info.type == "cdylib":
+        # Rustc generates the import library with a `.dll.lib` extension rather than the usual `.lib` one that msvc
+        # expects (see https://github.com/rust-lang/rust/pull/29520 for more context).
+        interface_library = ctx.actions.declare_file(crate_info.output.basename + ".lib")
+        outputs.append(interface_library)
+
+    # The action might generate extra output that we don't want to include in the `DefaultInfo` files.
+    action_outputs = list(outputs)
+
+    # Rustc generates a pdb file (on Windows) or a dsym folder (on macos) so provide it in an output group for crate
+    # types that benefit from having debug information in a separate file.
+    pdb_file = None
+    dsym_folder = None
+    if crate_info.type in ("cdylib", "bin") and not crate_info.is_test:
+        if toolchain.os == "windows":
+            pdb_file = ctx.actions.declare_file(crate_info.output.basename[:-len(crate_info.output.extension)] + "pdb")
+            action_outputs.append(pdb_file)
+        elif toolchain.os == "darwin":
+            dsym_folder = ctx.actions.declare_directory(crate_info.output.basename + ".dSYM")
+            action_outputs.append(dsym_folder)
+
+    # This uses startswith as on windows the basename will be process_wrapper_fake.exe.
+    if not ctx.executable._process_wrapper.basename.startswith("process_wrapper_fake"):
+        # Run as normal
+        ctx.actions.run(
+            executable = ctx.executable._process_wrapper,
+            inputs = compile_inputs,
+            outputs = action_outputs,
+            env = env,
+            arguments = args.all,
+            mnemonic = "Rustc",
+            progress_message = "Compiling Rust {} {}{} ({} files)".format(
+                crate_info.type,
+                ctx.label.name,
+                formatted_version,
+                len(crate_info.srcs.to_list()),
+            ),
+        )
+    else:
+        # Run without process_wrapper
+        if build_env_files or build_flags_files or stamp:
+            fail("build_env_files, build_flags_files, stamp are not supported if use_process_wrapper is False")
+        ctx.actions.run(
+            executable = toolchain.rustc,
+            inputs = compile_inputs,
+            outputs = action_outputs,
+            env = env,
+            arguments = [args.rustc_flags],
+            mnemonic = "Rustc",
+            progress_message = "Compiling Rust (without process_wrapper) {} {}{} ({} files)".format(
+                crate_info.type,
+                ctx.label.name,
+                formatted_version,
+                len(crate_info.srcs.to_list()),
+            ),
+        )
+
+    runfiles = ctx.runfiles(
+        files = getattr(ctx.files, "data", []),
+        collect_data = True,
+    )
+
+    # TODO: Remove after some resolution to
+    # https://github.com/bazelbuild/rules_rust/issues/771
+    out_binary = getattr(attr, "out_binary", False)
+
+    providers = [
+        crate_info,
+        dep_info,
+        DefaultInfo(
+            # nb. This field is required for cc_library to depend on our output.
+            files = depset(outputs),
+            runfiles = runfiles,
+            executable = crate_info.output if crate_info.type == "bin" or crate_info.is_test or out_binary else None,
+        ),
+    ]
+    if toolchain.target_arch != "wasm32":
+        providers += establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_configuration, interface_library)
+    if pdb_file:
+        providers.append(OutputGroupInfo(pdb_file = depset([pdb_file])))
+    if dsym_folder:
+        providers.append(OutputGroupInfo(dsym_folder = depset([dsym_folder])))
+
+    return providers
+
+def _is_dylib(dep):
+    return not bool(dep.static_library or dep.pic_static_library)
+
+def establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_configuration, interface_library):
+    """If the produced crate is suitable yield a CcInfo to allow for interop with cc rules
+
+    Args:
+        ctx (ctx): The rule's context object
+        attr (struct): Attributes to use in gathering CcInfo
+        crate_info (CrateInfo): The CrateInfo provider of the target crate
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        cc_toolchain (CcToolchainInfo): The current `CcToolchainInfo`
+        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
+        interface_library (File): Optional interface library for cdylib crates on Windows.
+
+    Returns:
+        list: A list containing the CcInfo provider
+    """
+
+    # A test will not need to produce CcInfo as nothing can depend on test targets
+    if crate_info.is_test:
+        return []
+
+    # Only generate CcInfo for particular crate types
+    if crate_info.type not in ("staticlib", "cdylib", "rlib", "lib"):
+        return []
+
+    # TODO: Remove after some resolution to
+    # https://github.com/bazelbuild/rules_rust/issues/771
+    if getattr(attr, "out_binary", False):
+        return []
+
+    if crate_info.type == "staticlib":
+        library_to_link = cc_common.create_library_to_link(
+            actions = ctx.actions,
+            feature_configuration = feature_configuration,
+            cc_toolchain = cc_toolchain,
+            static_library = crate_info.output,
+            # TODO(hlopko): handle PIC/NOPIC correctly
+            pic_static_library = crate_info.output,
+        )
+    elif crate_info.type in ("rlib", "lib"):
+        # bazel hard-codes a check for endswith((".a", ".pic.a",
+        # ".lib")) in create_library_to_link, so we work around that
+        # by creating a symlink to the .rlib with a .a extension.
+        dot_a = make_static_lib_symlink(ctx.actions, crate_info.output)
+
+        # TODO(hlopko): handle PIC/NOPIC correctly
+        library_to_link = cc_common.create_library_to_link(
+            actions = ctx.actions,
+            feature_configuration = feature_configuration,
+            cc_toolchain = cc_toolchain,
+            static_library = dot_a,
+            # TODO(hlopko): handle PIC/NOPIC correctly
+            pic_static_library = dot_a,
+        )
+    elif crate_info.type == "cdylib":
+        library_to_link = cc_common.create_library_to_link(
+            actions = ctx.actions,
+            feature_configuration = feature_configuration,
+            cc_toolchain = cc_toolchain,
+            dynamic_library = crate_info.output,
+            interface_library = interface_library,
+        )
+    else:
+        fail("Unexpected case")
+
+    link_input = cc_common.create_linker_input(
+        owner = ctx.label,
+        libraries = depset([library_to_link]),
+    )
+
+    linking_context = cc_common.create_linking_context(
+        # TODO - What to do for no_std?
+        linker_inputs = depset([link_input]),
+    )
+
+    cc_infos = [
+        CcInfo(linking_context = linking_context),
+        toolchain.stdlib_linkflags,
+    ]
+    for dep in getattr(attr, "deps", []):
+        if CcInfo in dep:
+            cc_infos.append(dep[CcInfo])
+
+    if crate_info.type in ("rlib", "lib") and toolchain.libstd_and_allocator_ccinfo:
+        # TODO: if we already have an rlib in our deps, we could skip this
+        cc_infos.append(toolchain.libstd_and_allocator_ccinfo)
+
+    return [cc_common.merge_cc_infos(cc_infos = cc_infos)]
+
+def add_edition_flags(args, crate):
+    """Adds the Rust edition flag to an arguments object reference
+
+    Args:
+        args (Args): A reference to an Args object
+        crate (CrateInfo): A CrateInfo provider
+    """
+    if crate.edition != "2015":
+        args.add("--edition={}".format(crate.edition))
+
+def _create_extra_input_args(build_info, dep_info):
+    """Gather additional input arguments from transitive dependencies
+
+    Args:
+        build_info (BuildInfo): The BuildInfo provider from the target Crate's set of inputs.
+        dep_info (DepInfo): The Depinfo provider form the target Crate's set of inputs.
+
+    Returns:
+        tuple: A tuple of the following items:
+            - (depset[File]): A list of all build info `OUT_DIR` File objects
+            - (str): The `OUT_DIR` of the current build info
+            - (File): An optional generated environment file from a `cargo_build_script` target
+            - (depset[File]): All direct and transitive build flag files from the current build info.
+    """
+    input_files = []
+
+    # Arguments to the commandline line wrapper that are going to be used
+    # to create the final command line
+    out_dir = None
+    build_env_file = None
+    build_flags_files = []
+
+    if build_info:
+        out_dir = build_info.out_dir.path
+        build_env_file = build_info.rustc_env
+        build_flags_files.append(build_info.flags)
+        build_flags_files.append(build_info.link_flags)
+        input_files.append(build_info.out_dir)
+        input_files.append(build_info.link_flags)
+
+    return (
+        depset(input_files, transitive = [dep_info.link_search_path_files]),
+        out_dir,
+        build_env_file,
+        depset(build_flags_files, transitive = [dep_info.link_search_path_files]),
+    )
+
+def _compute_rpaths(toolchain, output_dir, dep_info, use_pic):
+    """Determine the artifact's rpaths relative to the bazel root for runtime linking of shared libraries.
+
+    Args:
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        output_dir (str): The output directory of the current target
+        dep_info (DepInfo): The current target's dependency info
+        use_pic: If set, prefers pic_static_library over static_library.
+
+    Returns:
+        depset: A set of relative paths from the output directory to each dependency
+    """
+
+    # Windows has no rpath equivalent, so always return an empty depset.
+    if toolchain.os == "windows":
+        return depset([])
+
+    dylibs = [
+        get_preferred_artifact(lib, use_pic)
+        for linker_input in dep_info.transitive_noncrates.to_list()
+        for lib in linker_input.libraries
+        if _is_dylib(lib)
+    ]
+    if not dylibs:
+        return depset([])
+
+    # For darwin, dylibs compiled by Bazel will fail to be resolved at runtime
+    # without a version of Bazel that includes
+    # https://github.com/bazelbuild/bazel/pull/13427. This is known to not be
+    # included in Bazel 4.1 and below.
+    if toolchain.os != "linux" and toolchain.os != "darwin":
+        fail("Runtime linking is not supported on {}, but found {}".format(
+            toolchain.os,
+            dep_info.transitive_noncrates,
+        ))
+
+    # Multiple dylibs can be present in the same directory, so deduplicate them.
+    return depset([
+        relativize(lib_dir, output_dir)
+        for lib_dir in _get_dir_names(dylibs)
+    ])
+
+def _get_dir_names(files):
+    """Returns a list of directory names from the given list of File objects
+
+    Args:
+        files (list): A list of File objects
+
+    Returns:
+        list: A list of directory names for all files
+    """
+    dirs = {}
+    for f in files:
+        dirs[f.dirname] = None
+    return dirs.keys()
+
+def add_crate_link_flags(args, dep_info, force_all_deps_direct = False):
+    """Adds link flags to an Args object reference
+
+    Args:
+        args (Args): An arguments object reference
+        dep_info (DepInfo): The current target's dependency info
+        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
+            to the commandline as opposed to -L.
+    """
+
+    if force_all_deps_direct:
+        args.add_all(
+            depset(
+                transitive = [
+                    dep_info.direct_crates,
+                    dep_info.transitive_crates,
+                ],
+            ),
+            uniquify = True,
+            map_each = _crate_to_link_flag,
+        )
+    else:
+        # nb. Direct crates are linked via --extern regardless of their crate_type
+        args.add_all(dep_info.direct_crates, map_each = _crate_to_link_flag)
+    args.add_all(
+        dep_info.transitive_crates,
+        map_each = _get_crate_dirname,
+        uniquify = True,
+        format_each = "-Ldependency=%s",
+    )
+
+def _crate_to_link_flag(crate):
+    """A helper macro used by `add_crate_link_flags` for adding crate link flags to a Arg object
+
+    Args:
+        crate (CrateInfo|AliasableDepInfo): A CrateInfo or an AliasableDepInfo provider
+
+    Returns:
+        list: Link flags for the given provider
+    """
+
+    # This is AliasableDepInfo, we should use the alias as a crate name
+    if hasattr(crate, "dep"):
+        name = crate.name
+        crate_info = crate.dep
+    else:
+        name = crate.name
+        crate_info = crate
+    return ["--extern={}={}".format(name, crate_info.output.path)]
+
+def _get_crate_dirname(crate):
+    """A helper macro used by `add_crate_link_flags` for getting the directory name of the current crate's output path
+
+    Args:
+        crate (CrateInfo): A CrateInfo provider from the current rule
+
+    Returns:
+        str: The directory name of the the output File that will be produced.
+    """
+    return crate.output.dirname
+
+def _portable_link_flags(lib, use_pic, ambiguous_libs):
+    artifact = get_preferred_artifact(lib, use_pic)
+    if ambiguous_libs and artifact.path in ambiguous_libs:
+        artifact = ambiguous_libs[artifact.path]
+    if lib.static_library or lib.pic_static_library:
+        return [
+            "-lstatic=%s" % get_lib_name(artifact),
+        ]
+    elif _is_dylib(lib):
+        return [
+            "-ldylib=%s" % get_lib_name(artifact),
+        ]
+
+    return []
+
+def _make_link_flags_windows(linker_input_and_use_pic_and_ambiguous_libs):
+    linker_input, use_pic, ambiguous_libs = linker_input_and_use_pic_and_ambiguous_libs
+    ret = []
+    for lib in linker_input.libraries:
+        if lib.alwayslink:
+            ret.extend(["-C", "link-arg=/WHOLEARCHIVE:%s" % get_preferred_artifact(lib, use_pic).path])
+        else:
+            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs))
+    return ret
+
+def _make_link_flags_darwin(linker_input_and_use_pic_and_ambiguous_libs):
+    linker_input, use_pic, ambiguous_libs = linker_input_and_use_pic_and_ambiguous_libs
+    ret = []
+    for lib in linker_input.libraries:
+        if lib.alwayslink:
+            ret.extend([
+                "-C",
+                ("link-arg=-Wl,-force_load,%s" % get_preferred_artifact(lib, use_pic).path),
+            ])
+        else:
+            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs))
+    return ret
+
+def _make_link_flags_default(linker_input_and_use_pic_and_ambiguous_libs):
+    linker_input, use_pic, ambiguous_libs = linker_input_and_use_pic_and_ambiguous_libs
+    ret = []
+    for lib in linker_input.libraries:
+        if lib.alwayslink:
+            ret.extend([
+                "-C",
+                "link-arg=-Wl,--whole-archive",
+                "-C",
+                ("link-arg=%s" % get_preferred_artifact(lib, use_pic).path),
+                "-C",
+                "link-arg=-Wl,--no-whole-archive",
+            ])
+        else:
+            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs))
+    return ret
+
+def _libraries_dirnames(linker_input_and_use_pic_and_ambiguous_libs):
+    link_input, use_pic, _ = linker_input_and_use_pic_and_ambiguous_libs
+
+    # De-duplicate names.
+    return depset([get_preferred_artifact(lib, use_pic).dirname for lib in link_input.libraries]).to_list()
+
+def _add_native_link_flags(args, dep_info, linkstamp_outs, ambiguous_libs, crate_type, toolchain, cc_toolchain, feature_configuration):
+    """Adds linker flags for all dependencies of the current target.
+
+    Args:
+        args (Args): The Args struct for a ctx.action
+        dep_info (DepInfo): Dependency Info provider
+        linkstamp_outs (list): Linkstamp outputs of native dependencies
+        ambiguous_libs (dict): Ambiguous libs, see `_disambiguate_libs`
+        crate_type: Crate type of the current target
+        toolchain (rust_toolchain): The current `rust_toolchain`
+        cc_toolchain (CcToolchainInfo): The current `cc_toolchain`
+        feature_configuration (FeatureConfiguration): feature configuration to use with cc_toolchain
+
+    """
+    if crate_type in ["lib", "rlib"]:
+        return
+
+    use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_type)
+
+    if toolchain.os == "windows":
+        make_link_flags = _make_link_flags_windows
+    elif toolchain.os.startswith("mac") or toolchain.os.startswith("darwin"):
+        make_link_flags = _make_link_flags_darwin
+    else:
+        make_link_flags = _make_link_flags_default
+
+    # TODO(hlopko): Remove depset flattening by using lambdas once we are on >=Bazel 5.0
+    args_and_pic_and_ambiguous_libs = [(arg, use_pic, ambiguous_libs) for arg in dep_info.transitive_noncrates.to_list()]
+    args.add_all(args_and_pic_and_ambiguous_libs, map_each = _libraries_dirnames, uniquify = True, format_each = "-Lnative=%s")
+    if ambiguous_libs:
+        # If there are ambiguous libs, the disambiguation symlinks to them are
+        # all created in the same directory. Add it to the library search path.
+        ambiguous_libs_dirname = ambiguous_libs.values()[0].dirname
+        args.add("-Lnative={}".format(ambiguous_libs_dirname))
+
+    args.add_all(args_and_pic_and_ambiguous_libs, map_each = make_link_flags)
+
+    for linkstamp_out in linkstamp_outs:
+        args.add_all(["-C", "link-arg=%s" % linkstamp_out.path])
+
+    if crate_type in ["dylib", "cdylib"]:
+        # For shared libraries we want to link C++ runtime library dynamically
+        # (for example libstdc++.so or libc++.so).
+        args.add_all(
+            cc_toolchain.dynamic_runtime_lib(feature_configuration = feature_configuration),
+            map_each = _get_dirname,
+            format_each = "-Lnative=%s",
+        )
+        args.add_all(
+            cc_toolchain.dynamic_runtime_lib(feature_configuration = feature_configuration),
+            map_each = get_lib_name,
+            format_each = "-ldylib=%s",
+        )
+    else:
+        # For all other crate types we want to link C++ runtime library statically
+        # (for example libstdc++.a or libc++.a).
+        args.add_all(
+            cc_toolchain.static_runtime_lib(feature_configuration = feature_configuration),
+            map_each = _get_dirname,
+            format_each = "-Lnative=%s",
+        )
+        args.add_all(
+            cc_toolchain.static_runtime_lib(feature_configuration = feature_configuration),
+            map_each = get_lib_name,
+            format_each = "-lstatic=%s",
+        )
+
+def _get_dirname(file):
+    """A helper function for `_add_native_link_flags`.
+
+    Args:
+        file (File): The target file
+
+    Returns:
+        str: Directory name of `file`
+    """
+    return file.dirname
+
+def _error_format_impl(ctx):
+    """Implementation of the `error_format` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list containing the ErrorFormatInfo provider
+    """
+    raw = ctx.build_setting_value
+    if raw not in _error_format_values:
+        fail("{} expected a value in `{}` but got `{}`".format(
+            ctx.label,
+            _error_format_values,
+            raw,
+        ))
+    return [ErrorFormatInfo(error_format = raw)]
+
+error_format = rule(
+    doc = (
+        "Change the [--error-format](https://doc.rust-lang.org/rustc/command-line-arguments.html#option-error-format) " +
+        "flag from the command line with `--@rules_rust//:error_format`. See rustc documentation for valid values."
+    ),
+    implementation = _error_format_impl,
+    build_setting = config.string(flag = True),
+)
+
+def _extra_rustc_flags_impl(ctx):
+    return ExtraRustcFlagsInfo(extra_rustc_flags = ctx.build_setting_value)
+
+extra_rustc_flags = rule(
+    doc = (
+        "Add additional rustc_flags from the command line with `--@rules_rust//:extra_rustc_flags`. " +
+        "This flag should only be used for flags that need to be applied across the entire build. For options that " +
+        "apply to individual crates, use the rustc_flags attribute on the individual crate's rule instead. NOTE: " +
+        "These flags not applied to the exec configuration (proc-macros, cargo_build_script, etc); " +
+        "use `--@rules_rust//:extra_exec_rustc_flags` to apply flags to the exec configuration."
+    ),
+    implementation = _extra_rustc_flags_impl,
+    build_setting = config.string_list(flag = True),
+)
+
+def _extra_exec_rustc_flags_impl(ctx):
+    return ExtraExecRustcFlagsInfo(extra_exec_rustc_flags = ctx.build_setting_value)
+
+extra_exec_rustc_flags = rule(
+    doc = (
+        "Add additional rustc_flags in the exec configuration from the command line with `--@rules_rust//:extra_exec_rustc_flags`. " +
+        "This flag should only be used for flags that need to be applied across the entire build. " +
+        "These flags only apply to the exec configuration (proc-macros, cargo_build_script, etc)."
+    ),
+    implementation = _extra_exec_rustc_flags_impl,
+    build_setting = config.string_list(flag = True),
+)
diff --git a/third_party/rules_rust/rust/private/rustdoc.bzl b/third_party/rules_rust/rust/private/rustdoc.bzl
new file mode 100644
index 0000000..86c2acd
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rustdoc.bzl
@@ -0,0 +1,318 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Rules for generating documentation with `rustdoc` for Bazel built crates"""
+
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:rustc.bzl", "collect_deps", "collect_inputs", "construct_arguments")
+load("//rust/private:utils.bzl", "dedent", "find_cc_toolchain", "find_toolchain")
+
+def _strip_crate_info_output(crate_info):
+    """Set the CrateInfo.output to None for a given CrateInfo provider.
+
+    Args:
+        crate_info (CrateInfo): A provider
+
+    Returns:
+        CrateInfo: A modified CrateInfo provider
+    """
+    return rust_common.create_crate_info(
+        name = crate_info.name,
+        type = crate_info.type,
+        root = crate_info.root,
+        srcs = crate_info.srcs,
+        deps = crate_info.deps,
+        proc_macro_deps = crate_info.proc_macro_deps,
+        aliases = crate_info.aliases,
+        # This crate info should have no output
+        output = None,
+        edition = crate_info.edition,
+        rustc_env = crate_info.rustc_env,
+        is_test = crate_info.is_test,
+        compile_data = crate_info.compile_data,
+    )
+
+def rustdoc_compile_action(
+        ctx,
+        toolchain,
+        crate_info,
+        output = None,
+        rustdoc_flags = [],
+        is_test = False):
+    """Create a struct of information needed for a `rustdoc` compile action based on crate passed to the rustdoc rule.
+
+    Args:
+        ctx (ctx): The rule's context object.
+        toolchain (rust_toolchain): The currently configured `rust_toolchain`.
+        crate_info (CrateInfo): The provider of the crate passed to a rustdoc rule.
+        output (File, optional): An optional output a `rustdoc` action is intended to produce.
+        rustdoc_flags (list, optional): A list of `rustdoc` specific flags.
+        is_test (bool, optional): If True, the action will be configured for `rust_doc_test` targets
+
+    Returns:
+        struct: A struct of some `ctx.actions.run` arguments.
+    """
+
+    # If an output was provided, ensure it's used in rustdoc arguments
+    if output:
+        rustdoc_flags = [
+            "--output",
+            output.path,
+        ] + rustdoc_flags
+
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+
+    dep_info, build_info, linkstamps = collect_deps(
+        deps = crate_info.deps,
+        proc_macro_deps = crate_info.proc_macro_deps,
+        aliases = crate_info.aliases,
+    )
+
+    compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs = collect_inputs(
+        ctx = ctx,
+        file = ctx.file,
+        files = ctx.files,
+        linkstamps = linkstamps,
+        toolchain = toolchain,
+        cc_toolchain = cc_toolchain,
+        feature_configuration = feature_configuration,
+        crate_info = crate_info,
+        dep_info = dep_info,
+        build_info = build_info,
+    )
+
+    # Since this crate is not actually producing the output described by the
+    # given CrateInfo, this attribute needs to be stripped to allow the rest
+    # of the rustc functionality in `construct_arguments` to avoid generating
+    # arguments expecting to do so.
+    rustdoc_crate_info = _strip_crate_info_output(crate_info)
+
+    args, env = construct_arguments(
+        ctx = ctx,
+        attr = ctx.attr,
+        file = ctx.file,
+        toolchain = toolchain,
+        tool_path = toolchain.rust_doc.short_path if is_test else toolchain.rust_doc.path,
+        cc_toolchain = cc_toolchain,
+        feature_configuration = feature_configuration,
+        crate_info = rustdoc_crate_info,
+        dep_info = dep_info,
+        linkstamp_outs = linkstamp_outs,
+        ambiguous_libs = ambiguous_libs,
+        output_hash = None,
+        rust_flags = rustdoc_flags,
+        out_dir = out_dir,
+        build_env_files = build_env_files,
+        build_flags_files = build_flags_files,
+        emit = [],
+        remap_path_prefix = None,
+        force_link = True,
+    )
+
+    # Because rustdoc tests compile tests outside of the sandbox, the sysroot
+    # must be updated to the `short_path` equivilant as it will now be
+    # a part of runfiles.
+    if is_test:
+        if "SYSROOT" in env:
+            env.update({"SYSROOT": "${{pwd}}/{}".format(toolchain.sysroot_short_path)})
+
+        # `rustdoc` does not support the SYSROOT environment variable. To account
+        # for this, the flag must be explicitly passed to the `rustdoc` binary.
+        args.rustc_flags.add("--sysroot=${{pwd}}/{}".format(toolchain.sysroot_short_path))
+
+    return struct(
+        executable = ctx.executable._process_wrapper,
+        inputs = depset([crate_info.output], transitive = [compile_inputs]),
+        env = env,
+        arguments = args.all,
+        tools = [toolchain.rust_doc],
+    )
+
+def _zip_action(ctx, input_dir, output_zip, crate_label):
+    """Creates an archive of the generated documentation from `rustdoc`
+
+    Args:
+        ctx (ctx): The `rust_doc` rule's context object
+        input_dir (File): A directory containing the outputs from rustdoc
+        output_zip (File): The location of the output archive containing generated documentation
+        crate_label (Label): The label of the crate docs are being generated for.
+    """
+    args = ctx.actions.args()
+    args.add(ctx.executable._zipper)
+    args.add(output_zip)
+    args.add(ctx.bin_dir.path)
+    args.add_all([input_dir], expand_directories = True)
+    ctx.actions.run(
+        executable = ctx.executable._dir_zipper,
+        inputs = [input_dir],
+        outputs = [output_zip],
+        arguments = [args],
+        mnemonic = "RustdocZip",
+        progress_message = "Creating RustdocZip for {}".format(crate_label),
+        tools = [ctx.executable._zipper],
+    )
+
+def _rust_doc_impl(ctx):
+    """The implementation of the `rust_doc` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+    """
+
+    crate = ctx.attr.crate
+    crate_info = crate[rust_common.crate_info]
+
+    output_dir = ctx.actions.declare_directory("{}.rustdoc".format(ctx.label.name))
+
+    # Add the current crate as an extern for the compile action
+    rustdoc_flags = [
+        "--extern",
+        "{}={}".format(crate_info.name, crate_info.output.path),
+    ]
+
+    action = rustdoc_compile_action(
+        ctx = ctx,
+        toolchain = find_toolchain(ctx),
+        crate_info = crate_info,
+        output = output_dir,
+        rustdoc_flags = rustdoc_flags,
+    )
+
+    ctx.actions.run(
+        mnemonic = "Rustdoc",
+        progress_message = "Generating Rustdoc for {}".format(crate.label),
+        outputs = [output_dir],
+        executable = action.executable,
+        inputs = action.inputs,
+        env = action.env,
+        arguments = action.arguments,
+        tools = action.tools,
+    )
+
+    # This rule does nothing without a single-file output, though the directory should've sufficed.
+    _zip_action(ctx, output_dir, ctx.outputs.rust_doc_zip, crate.label)
+
+    return [
+        DefaultInfo(
+            files = depset([ctx.outputs.rust_doc_zip]),
+        ),
+        OutputGroupInfo(
+            rustdoc_dir = depset([output_dir]),
+            rustdoc_zip = depset([ctx.outputs.rust_doc_zip]),
+        ),
+    ]
+
+rust_doc = rule(
+    doc = dedent("""\
+    Generates code documentation.
+
+    Example:
+    Suppose you have the following directory structure for a Rust library crate:
+
+    ```
+    [workspace]/
+        WORKSPACE
+        hello_lib/
+            BUILD
+            src/
+                lib.rs
+    ```
+
+    To build [`rustdoc`][rustdoc] documentation for the `hello_lib` crate, define \
+    a `rust_doc` rule that depends on the the `hello_lib` `rust_library` target:
+
+    [rustdoc]: https://doc.rust-lang.org/book/documentation.html
+
+    ```python
+    package(default_visibility = ["//visibility:public"])
+
+    load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc")
+
+    rust_library(
+        name = "hello_lib",
+        srcs = ["src/lib.rs"],
+    )
+
+    rust_doc(
+        name = "hello_lib_doc",
+        crate = ":hello_lib",
+    )
+    ```
+
+    Running `bazel build //hello_lib:hello_lib_doc` will build a zip file containing \
+    the documentation for the `hello_lib` library crate generated by `rustdoc`.
+    """),
+    implementation = _rust_doc_impl,
+    attrs = {
+        "crate": attr.label(
+            doc = (
+                "The label of the target to generate code documentation for.\n" +
+                "\n" +
+                "`rust_doc` can generate HTML code documentation for the source files of " +
+                "`rust_library` or `rust_binary` targets."
+            ),
+            providers = [rust_common.crate_info],
+            mandatory = True,
+        ),
+        "html_after_content": attr.label(
+            doc = "File to add in `<body>`, after content.",
+            allow_single_file = [".html", ".md"],
+        ),
+        "html_before_content": attr.label(
+            doc = "File to add in `<body>`, before content.",
+            allow_single_file = [".html", ".md"],
+        ),
+        "html_in_header": attr.label(
+            doc = "File to add to `<head>`.",
+            allow_single_file = [".html", ".md"],
+        ),
+        "markdown_css": attr.label_list(
+            doc = "CSS files to include via `<link>` in a rendered Markdown file.",
+            allow_files = [".css"],
+        ),
+        "_cc_toolchain": attr.label(
+            doc = "In order to use find_cpp_toolchain, you must define the '_cc_toolchain' attribute on your rule or aspect.",
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_dir_zipper": attr.label(
+            doc = "A tool that orchestrates the creation of zip archives for rustdoc outputs.",
+            default = Label("//util/dir_zipper"),
+            cfg = "exec",
+            executable = True,
+        ),
+        "_process_wrapper": attr.label(
+            doc = "A process wrapper for running rustdoc on all platforms",
+            default = Label("@rules_rust//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+        "_zipper": attr.label(
+            doc = "A Bazel provided tool for creating archives",
+            default = Label("@bazel_tools//tools/zip:zipper"),
+            cfg = "exec",
+            executable = True,
+        ),
+    },
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    outputs = {
+        "rust_doc_zip": "%{name}.zip",
+    },
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+)
diff --git a/third_party/rules_rust/rust/private/rustdoc_test.bzl b/third_party/rules_rust/rust/private/rustdoc_test.bzl
new file mode 100644
index 0000000..663c65f
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rustdoc_test.bzl
@@ -0,0 +1,225 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Rules for performing `rustdoc --test` on Bazel built crates"""
+
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:rustdoc.bzl", "rustdoc_compile_action")
+load("//rust/private:utils.bzl", "dedent", "find_toolchain")
+
+def _construct_writer_arguments(ctx, test_runner, action, crate_info):
+    """Construct arguments and environment variables specific to `rustdoc_test_writer`.
+
+    This is largely solving for the fact that tests run from a runfiles directory
+    where actions run in an execroot. But it also tracks what environment variables
+    were explicitly added to the action.
+
+    Args:
+        ctx (ctx): The rule's context object.
+        test_runner (File): The test_runner output file declared by `rustdoc_test`.
+        action (struct): Action arguments generated by `rustdoc_compile_action`.
+        crate_info (CrateInfo): The provider of the crate who's docs are being tested.
+
+    Returns:
+        tuple: A tuple of `rustdoc_test_writer` specific inputs
+            - Args: Arguments for the test writer
+            - dict: Required environment variables
+    """
+
+    writer_args = ctx.actions.args()
+
+    # Track the output path where the test writer should write the test
+    writer_args.add("--output={}".format(test_runner.path))
+
+    # Track what environment variables should be written to the test runner
+    writer_args.add("--action_env=DEVELOPER_DIR")
+    writer_args.add("--action_env=PATHEXT")
+    writer_args.add("--action_env=SDKROOT")
+    writer_args.add("--action_env=SYSROOT")
+    for var in action.env.keys():
+        writer_args.add("--action_env={}".format(var))
+
+    # Since the test runner will be running from a runfiles directory, the
+    # paths originally generated for the build action will not map to any
+    # files. To ensure rustdoc can find the appropriate dependencies, the
+    # file roots are identified and tracked for each dependency so it can be
+    # stripped from the test runner.
+    for dep in crate_info.deps.to_list():
+        dep_crate_info = getattr(dep, "crate_info", None)
+        dep_dep_info = getattr(dep, "dep_info", None)
+        if dep_crate_info:
+            root = dep_crate_info.output.root.path
+            writer_args.add("--strip_substring={}/".format(root))
+        if dep_dep_info:
+            for direct_dep in dep_dep_info.direct_crates.to_list():
+                root = direct_dep.dep.output.root.path
+                writer_args.add("--strip_substring={}/".format(root))
+            for transitive_dep in dep_dep_info.transitive_crates.to_list():
+                root = transitive_dep.output.root.path
+                writer_args.add("--strip_substring={}/".format(root))
+
+    # Indicate that the rustdoc_test args are over.
+    writer_args.add("--")
+
+    # Prepare for the process runner to ingest the rest of the arguments
+    # to match the expectations of `rustc_compile_action`.
+    writer_args.add(ctx.executable._process_wrapper.short_path)
+
+    return (writer_args, action.env)
+
+def _rust_doc_test_impl(ctx):
+    """The implementation for the `rust_doc_test` rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list containing a DefaultInfo provider
+    """
+
+    toolchain = find_toolchain(ctx)
+
+    crate = ctx.attr.crate
+    crate_info = crate[rust_common.crate_info]
+
+    if toolchain.os == "windows":
+        test_runner = ctx.actions.declare_file(ctx.label.name + ".rustdoc_test.bat")
+    else:
+        test_runner = ctx.actions.declare_file(ctx.label.name + ".rustdoc_test.sh")
+
+    # Add the current crate as an extern for the compile action
+    rustdoc_flags = [
+        "--extern",
+        "{}={}".format(crate_info.name, crate_info.output.short_path),
+        "--test",
+    ]
+
+    action = rustdoc_compile_action(
+        ctx = ctx,
+        toolchain = toolchain,
+        crate_info = crate_info,
+        rustdoc_flags = rustdoc_flags,
+        is_test = True,
+    )
+
+    tools = action.tools + [ctx.executable._process_wrapper]
+
+    writer_args, env = _construct_writer_arguments(
+        ctx = ctx,
+        test_runner = test_runner,
+        action = action,
+        crate_info = crate_info,
+    )
+
+    # Allow writer environment variables to override those from the action.
+    action.env.update(env)
+
+    ctx.actions.run(
+        mnemonic = "RustdocTestWriter",
+        progress_message = "Generating Rustdoc test runner for {}".format(crate.label),
+        executable = ctx.executable._test_writer,
+        inputs = action.inputs,
+        tools = tools,
+        arguments = [writer_args] + action.arguments,
+        env = action.env,
+        outputs = [test_runner],
+    )
+
+    return [DefaultInfo(
+        files = depset([test_runner]),
+        runfiles = ctx.runfiles(files = tools, transitive_files = action.inputs),
+        executable = test_runner,
+    )]
+
+rust_doc_test = rule(
+    implementation = _rust_doc_test_impl,
+    attrs = {
+        "crate": attr.label(
+            doc = (
+                "The label of the target to generate code documentation for. " +
+                "`rust_doc_test` can generate HTML code documentation for the " +
+                "source files of `rust_library` or `rust_binary` targets."
+            ),
+            providers = [rust_common.crate_info],
+            mandatory = True,
+        ),
+        "_cc_toolchain": attr.label(
+            doc = (
+                "In order to use find_cc_toolchain, your rule has to depend " +
+                "on C++ toolchain. See @rules_cc//cc:find_cc_toolchain.bzl " +
+                "docs for details."
+            ),
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_process_wrapper": attr.label(
+            doc = "A process wrapper for running rustdoc on all platforms",
+            cfg = "exec",
+            default = Label("//util/process_wrapper"),
+            executable = True,
+        ),
+        "_test_writer": attr.label(
+            doc = "A binary used for writing script for use as the test executable.",
+            cfg = "exec",
+            default = Label("//tools/rustdoc:rustdoc_test_writer"),
+            executable = True,
+        ),
+    },
+    test = True,
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = dedent("""\
+        Runs Rust documentation tests.
+
+        Example:
+
+        Suppose you have the following directory structure for a Rust library crate:
+
+        ```output
+        [workspace]/
+        WORKSPACE
+        hello_lib/
+            BUILD
+            src/
+                lib.rs
+        ```
+
+        To run [documentation tests][doc-test] for the `hello_lib` crate, define a `rust_doc_test` \
+        target that depends on the `hello_lib` `rust_library` target:
+
+        [doc-test]: https://doc.rust-lang.org/book/documentation.html#documentation-as-tests
+
+        ```python
+        package(default_visibility = ["//visibility:public"])
+
+        load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc_test")
+
+        rust_library(
+            name = "hello_lib",
+            srcs = ["src/lib.rs"],
+        )
+
+        rust_doc_test(
+            name = "hello_lib_doc_test",
+            crate = ":hello_lib",
+        )
+        ```
+
+        Running `bazel test //hello_lib:hello_lib_doc_test` will run all documentation tests for the `hello_lib` library crate.
+    """),
+)
diff --git a/third_party/rules_rust/rust/private/rustfmt.bzl b/third_party/rules_rust/rust/private/rustfmt.bzl
new file mode 100644
index 0000000..9c59f48
--- /dev/null
+++ b/third_party/rules_rust/rust/private/rustfmt.bzl
@@ -0,0 +1,186 @@
+"""A module defining rustfmt rules"""
+
+load(":common.bzl", "rust_common")
+load(":utils.bzl", "find_toolchain")
+
+def _find_rustfmtable_srcs(target, aspect_ctx = None):
+    """Parse a target for rustfmt formattable sources.
+
+    Args:
+        target (Target): The target the aspect is running on.
+        aspect_ctx (ctx, optional): The aspect's context object.
+
+    Returns:
+        list: A list of formattable sources (`File`).
+    """
+    if rust_common.crate_info not in target:
+        return []
+
+    # Ignore external targets
+    if target.label.workspace_root.startswith("external"):
+        return []
+
+    # Targets annotated with `norustfmt` will not be formatted
+    if aspect_ctx and "norustfmt" in aspect_ctx.rule.attr.tags:
+        return []
+
+    crate_info = target[rust_common.crate_info]
+
+    # Filter out any generated files
+    srcs = [src for src in crate_info.srcs.to_list() if src.is_source]
+
+    return srcs
+
+def _generate_manifest(edition, srcs, ctx):
+    # Gather the source paths to non-generated files
+    src_paths = [src.path for src in srcs]
+
+    # Write the rustfmt manifest
+    manifest = ctx.actions.declare_file(ctx.label.name + ".rustfmt")
+    ctx.actions.write(
+        output = manifest,
+        content = "\n".join(src_paths + [
+            edition,
+        ]),
+    )
+
+    return manifest
+
+def _perform_check(edition, srcs, ctx):
+    toolchain = find_toolchain(ctx)
+    config = ctx.file._config
+    marker = ctx.actions.declare_file(ctx.label.name + ".rustfmt.ok")
+
+    args = ctx.actions.args()
+    args.add("--touch-file")
+    args.add(marker)
+    args.add("--")
+    args.add(toolchain.rustfmt)
+    args.add("--config-path")
+    args.add(config)
+    args.add("--edition")
+    args.add(edition)
+    args.add("--check")
+    args.add_all(srcs)
+
+    ctx.actions.run(
+        executable = ctx.executable._process_wrapper,
+        inputs = srcs + [config],
+        outputs = [marker],
+        tools = [toolchain.rustfmt],
+        arguments = [args],
+        mnemonic = "Rustfmt",
+    )
+
+    return marker
+
+def _rustfmt_aspect_impl(target, ctx):
+    srcs = _find_rustfmtable_srcs(target, ctx)
+
+    # If there are no formattable sources, do nothing.
+    if not srcs:
+        return []
+
+    # Parse the edition to use for formatting from the target
+    edition = target[rust_common.crate_info].edition
+
+    manifest = _generate_manifest(edition, srcs, ctx)
+    marker = _perform_check(edition, srcs, ctx)
+
+    return [
+        OutputGroupInfo(
+            rustfmt_manifest = depset([manifest]),
+            rustfmt_checks = depset([marker]),
+        ),
+    ]
+
+rustfmt_aspect = aspect(
+    implementation = _rustfmt_aspect_impl,
+    doc = """\
+This aspect is used to gather information about a crate for use in rustfmt and perform rustfmt checks
+
+Output Groups:
+
+- `rustfmt_manifest`: A manifest used by rustfmt binaries to provide crate specific settings.
+- `rustfmt_checks`: Executes `rustfmt --check` on the specified target.
+
+The build setting `@rules_rust//:rustfmt.toml` is used to control the Rustfmt [configuration settings][cs]
+used at runtime.
+
+[cs]: https://rust-lang.github.io/rustfmt/
+
+This aspect is executed on any target which provides the `CrateInfo` provider. However
+users may tag a target with `norustfmt` to have it skipped. Additionally, generated
+source files are also ignored by this aspect.
+""",
+    attrs = {
+        "_config": attr.label(
+            doc = "The `rustfmt.toml` file used for formatting",
+            allow_single_file = True,
+            default = Label("//:rustfmt.toml"),
+        ),
+        "_process_wrapper": attr.label(
+            doc = "A process wrapper for running rustfmt on all platforms",
+            cfg = "exec",
+            executable = True,
+            default = Label("//util/process_wrapper"),
+        ),
+    },
+    incompatible_use_toolchain_transition = True,
+    fragments = ["cpp"],
+    host_fragments = ["cpp"],
+    toolchains = [
+        str(Label("//rust:toolchain")),
+    ],
+)
+
+def _rustfmt_test_impl(ctx):
+    # The executable of a test target must be the output of an action in
+    # the rule implementation. This file is simply a symlink to the real
+    # rustfmt test runner.
+    runner = ctx.actions.declare_file("{}{}".format(
+        ctx.label.name,
+        ctx.executable._runner.extension,
+    ))
+
+    ctx.actions.symlink(
+        output = runner,
+        target_file = ctx.executable._runner,
+        is_executable = True,
+    )
+
+    manifests = [target[OutputGroupInfo].rustfmt_manifest for target in ctx.attr.targets]
+    srcs = [depset(_find_rustfmtable_srcs(target)) for target in ctx.attr.targets]
+
+    runfiles = ctx.runfiles(
+        transitive_files = depset(transitive = manifests + srcs),
+    )
+
+    runfiles = runfiles.merge(
+        ctx.attr._runner[DefaultInfo].default_runfiles,
+    )
+
+    return [DefaultInfo(
+        files = depset([runner]),
+        runfiles = runfiles,
+        executable = runner,
+    )]
+
+rustfmt_test = rule(
+    implementation = _rustfmt_test_impl,
+    doc = "A test rule for performing `rustfmt --check` on a set of targets",
+    attrs = {
+        "targets": attr.label_list(
+            doc = "Rust targets to run `rustfmt --check` on.",
+            providers = [rust_common.crate_info],
+            aspects = [rustfmt_aspect],
+        ),
+        "_runner": attr.label(
+            doc = "The rustfmt test runner",
+            cfg = "exec",
+            executable = True,
+            default = Label("//tools/rustfmt:rustfmt_test"),
+        ),
+    },
+    test = True,
+)
diff --git a/third_party/rules_rust/rust/private/stamp.bzl b/third_party/rules_rust/rust/private/stamp.bzl
new file mode 100644
index 0000000..1a7cab6
--- /dev/null
+++ b/third_party/rules_rust/rust/private/stamp.bzl
@@ -0,0 +1,75 @@
+"""A small utility module dedicated to detecting whether or not the `--stamp` flag is enabled
+
+This module can be removed likely after the following PRs ar addressed:
+- https://github.com/bazelbuild/bazel/issues/11164
+"""
+
+load("//rust/private:utils.bzl", "dedent")
+
+StampSettingInfo = provider(
+    doc = "Information about the `--stamp` command line flag",
+    fields = {
+        "value": "bool: Whether or not the `--stamp` flag was enabled",
+    },
+)
+
+def _stamp_build_setting_impl(ctx):
+    return StampSettingInfo(value = ctx.attr.value)
+
+_stamp_build_setting = rule(
+    doc = dedent("""\
+        Whether to encode build information into the binary. Possible values:
+
+        - stamp = 1: Always stamp the build information into the binary, even in [--nostamp][stamp] builds. \
+        This setting should be avoided, since it potentially kills remote caching for the binary and \
+        any downstream actions that depend on it.
+        - stamp = 0: Always replace build information by constant values. This gives good build result caching.
+        - stamp = -1: Embedding of build information is controlled by the [--[no]stamp][stamp] flag.
+
+        Stamped binaries are not rebuilt unless their dependencies change.
+        [stamp]: https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
+    """),
+    implementation = _stamp_build_setting_impl,
+    attrs = {
+        "value": attr.bool(
+            doc = "The default value of the stamp build flag",
+            mandatory = True,
+        ),
+    },
+)
+
+def stamp_build_setting(name, visibility = ["//visibility:public"]):
+    native.config_setting(
+        name = "stamp_detect",
+        values = {"stamp": "1"},
+        visibility = visibility,
+    )
+
+    _stamp_build_setting(
+        name = name,
+        value = select({
+            ":stamp_detect": True,
+            "//conditions:default": False,
+        }),
+        visibility = visibility,
+    )
+
+def is_stamping_enabled(attr):
+    """Determine whether or not build stamping is enabled
+
+    Args:
+        attr (struct): A rule's struct of attributes (`ctx.attr`)
+
+    Returns:
+        bool: The stamp value
+    """
+    stamp_num = getattr(attr, "stamp", -1)
+    if stamp_num == 1:
+        return True
+    elif stamp_num == 0:
+        return False
+    elif stamp_num == -1:
+        stamp_flag = getattr(attr, "_stamp_flag", None)
+        return stamp_flag[StampSettingInfo].value if stamp_flag else False
+    else:
+        fail("Unexpected `stamp` value: {}".format(stamp_num))
diff --git a/third_party/rules_rust/rust/private/toolchain_utils.bzl b/third_party/rules_rust/rust/private/toolchain_utils.bzl
new file mode 100644
index 0000000..fcd4fb7
--- /dev/null
+++ b/third_party/rules_rust/rust/private/toolchain_utils.bzl
@@ -0,0 +1,82 @@
+"""A module defining toolchain utilities"""
+
+def _toolchain_files_impl(ctx):
+    toolchain = ctx.toolchains[str(Label("//rust:toolchain"))]
+
+    runfiles = None
+    if ctx.attr.tool == "cargo":
+        files = depset([toolchain.cargo])
+        runfiles = ctx.runfiles(
+            files = [
+                toolchain.cargo,
+                toolchain.rustc,
+            ],
+            transitive_files = toolchain.rustc_lib,
+        )
+    elif ctx.attr.tool == "clippy":
+        files = depset([toolchain.clippy_driver])
+        runfiles = ctx.runfiles(
+            files = [
+                toolchain.clippy_driver,
+                toolchain.rustc,
+            ],
+            transitive_files = toolchain.rustc_lib,
+        )
+    elif ctx.attr.tool == "rustc":
+        files = depset([toolchain.rustc])
+        runfiles = ctx.runfiles(
+            files = [toolchain.rustc],
+            transitive_files = toolchain.rustc_lib,
+        )
+    elif ctx.attr.tool == "rustdoc":
+        files = depset([toolchain.rust_doc])
+        runfiles = ctx.runfiles(
+            files = [toolchain.rust_doc],
+            transitive_files = toolchain.rustc_lib,
+        )
+    elif ctx.attr.tool == "rustfmt":
+        files = depset([toolchain.rustfmt])
+        runfiles = ctx.runfiles(
+            files = [toolchain.rustfmt],
+            transitive_files = toolchain.rustc_lib,
+        )
+    elif ctx.attr.tool == "rustc_lib":
+        files = toolchain.rustc_lib
+    elif ctx.attr.tool == "rustc_srcs":
+        files = toolchain.rustc_srcs.files
+    elif ctx.attr.tool == "rust_std" or ctx.attr.tool == "rust_stdlib" or ctx.attr.tool == "rust_lib":
+        files = toolchain.rust_std
+    else:
+        fail("Unsupported tool: ", ctx.attr.tool)
+
+    return [DefaultInfo(
+        files = files,
+        runfiles = runfiles,
+    )]
+
+toolchain_files = rule(
+    doc = "A rule for fetching files from a rust toolchain.",
+    implementation = _toolchain_files_impl,
+    attrs = {
+        "tool": attr.string(
+            doc = "The desired tool to get form the current rust_toolchain",
+            values = [
+                "cargo",
+                "clippy",
+                "rust_lib",
+                "rust_std",
+                "rust_stdlib",
+                "rustc_lib",
+                "rustc_srcs",
+                "rustc",
+                "rustdoc",
+                "rustfmt",
+            ],
+            mandatory = True,
+        ),
+    },
+    toolchains = [
+        str(Label("//rust:toolchain")),
+    ],
+    incompatible_use_toolchain_transition = True,
+)
diff --git a/third_party/rules_rust/rust/private/transitions.bzl b/third_party/rules_rust/rust/private/transitions.bzl
new file mode 100644
index 0000000..cd28efd
--- /dev/null
+++ b/third_party/rules_rust/rust/private/transitions.bzl
@@ -0,0 +1,111 @@
+# buildifier: disable=module-docstring
+load("//rust:defs.bzl", "rust_common")
+
+def _wasm_bindgen_transition(_settings, _attr):
+    """The implementation of the `wasm_bindgen_transition` transition
+
+    Args:
+        _settings (dict): A dict {String:Object} of all settings declared
+            in the inputs parameter to `transition()`
+        _attr (dict): A dict of attributes and values of the rule to which
+            the transition is attached
+
+    Returns:
+        dict: A dict of new build settings values to apply
+    """
+    return {"//command_line_option:platforms": str(Label("//rust/platform:wasm"))}
+
+wasm_bindgen_transition = transition(
+    implementation = _wasm_bindgen_transition,
+    inputs = [],
+    outputs = ["//command_line_option:platforms"],
+)
+
+def _import_macro_dep_bootstrap_transition(_settings, _attr):
+    """The implementation of the `import_macro_dep_bootstrap_transition` transition.
+
+    This transition modifies the config to start using the fake macro
+    implementation, so that the macro itself can be bootstrapped without
+    creating a dependency cycle, even while every Rust target has an implicit
+    dependency on the "import" macro (either real or fake).
+
+    Args:
+        _settings (dict): a dict {String:Object} of all settings declared in the
+            inputs parameter to `transition()`.
+        _attr (dict): A dict of attributes and values of the rule to which the
+            transition is attached.
+
+    Returns:
+        dict: A dict of new build settings values to apply.
+    """
+    return {"@rules_rust//rust/settings:use_real_import_macro": False}
+
+import_macro_dep_bootstrap_transition = transition(
+    implementation = _import_macro_dep_bootstrap_transition,
+    inputs = [],
+    outputs = ["@rules_rust//rust/settings:use_real_import_macro"],
+)
+
+def _with_import_macro_bootstrapping_mode_impl(ctx):
+    target = ctx.attr.target[0]
+    return [target[rust_common.crate_info], target[rust_common.dep_info]]
+
+with_import_macro_bootstrapping_mode = rule(
+    implementation = _with_import_macro_bootstrapping_mode_impl,
+    attrs = {
+        "target": attr.label(
+            cfg = import_macro_dep_bootstrap_transition,
+            allow_single_file = True,
+            mandatory = True,
+            executable = False,
+        ),
+        "_allowlist_function_transition": attr.label(
+            default = Label("//tools/allowlists/function_transition_allowlist"),
+        ),
+    },
+)
+
+def _without_process_wrapper_transition_impl(_settings, _attr):
+    """This transition allows rust_* rules to invoke rustc without process_wrapper."""
+    return {
+        "//rust/settings:use_process_wrapper": False,
+    }
+
+without_process_wrapper_transition = transition(
+    implementation = _without_process_wrapper_transition_impl,
+    inputs = [],
+    outputs = ["//rust/settings:use_process_wrapper"],
+)
+
+def _without_process_wrapper_impl(ctx):
+    executable = ctx.executable.target
+    link_name = ctx.label.name
+
+    # Append .exe if on windows
+    if executable.extension:
+        link_name = link_name + "." + executable.extension
+    link = ctx.actions.declare_file(link_name)
+    ctx.actions.symlink(
+        output = link,
+        target_file = executable,
+    )
+    return [
+        DefaultInfo(
+            executable = link,
+        ),
+    ]
+
+without_process_wrapper = rule(
+    implementation = _without_process_wrapper_impl,
+    attrs = {
+        "target": attr.label(
+            cfg = without_process_wrapper_transition,
+            allow_single_file = True,
+            mandatory = True,
+            executable = True,
+        ),
+        "_allowlist_function_transition": attr.label(
+            default = Label("//tools/allowlists/function_transition_allowlist"),
+        ),
+    },
+)
diff --git a/third_party/rules_rust/rust/private/utils.bzl b/third_party/rules_rust/rust/private/utils.bzl
new file mode 100644
index 0000000..fa7318b
--- /dev/null
+++ b/third_party/rules_rust/rust/private/utils.bzl
@@ -0,0 +1,576 @@
+# Copyright 2015 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Utility functions not specific to the rust toolchain."""
+
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", find_rules_cc_toolchain = "find_cpp_toolchain")
+load(":providers.bzl", "BuildInfo", "CrateInfo", "DepInfo", "DepVariantInfo")
+
+def find_toolchain(ctx):
+    """Finds the first rust toolchain that is configured.
+
+    Args:
+        ctx (ctx): The ctx object for the current target.
+
+    Returns:
+        rust_toolchain: A Rust toolchain context.
+    """
+    return ctx.toolchains[Label("//rust:toolchain")]
+
+def find_cc_toolchain(ctx):
+    """Extracts a CcToolchain from the current target's context
+
+    Args:
+        ctx (ctx): The current target's rule context object
+
+    Returns:
+        tuple: A tuple of (CcToolchain, FeatureConfiguration)
+    """
+    cc_toolchain = find_rules_cc_toolchain(ctx)
+
+    feature_configuration = cc_common.configure_features(
+        ctx = ctx,
+        cc_toolchain = cc_toolchain,
+        requested_features = ctx.features,
+        unsupported_features = ctx.disabled_features,
+    )
+    return cc_toolchain, feature_configuration
+
+# TODO: Replace with bazel-skylib's `path.dirname`. This requires addressing some
+# dependency issues or generating docs will break.
+def relativize(path, start):
+    """Returns the relative path from start to path.
+
+    Args:
+        path (str): The path to relativize.
+        start (str): The ancestor path against which to relativize.
+
+    Returns:
+        str: The portion of `path` that is relative to `start`.
+    """
+    src_parts = _path_parts(start)
+    dest_parts = _path_parts(path)
+    n = 0
+    for src_part, dest_part in zip(src_parts, dest_parts):
+        if src_part != dest_part:
+            break
+        n += 1
+
+    relative_path = ""
+    for _ in range(n, len(src_parts)):
+        relative_path += "../"
+    relative_path += "/".join(dest_parts[n:])
+
+    return relative_path
+
+def _path_parts(path):
+    """Takes a path and returns a list of its parts with all "." elements removed.
+
+    The main use case of this function is if one of the inputs to relativize()
+    is a relative path, such as "./foo".
+
+    Args:
+      path (str): A string representing a unix path
+
+    Returns:
+      list: A list containing the path parts with all "." elements removed.
+    """
+    path_parts = path.split("/")
+    return [part for part in path_parts if part != "."]
+
+def get_lib_name(lib):
+    """Returns the name of a library artifact, eg. libabc.a -> abc
+
+    Args:
+        lib (File): A library file
+
+    Returns:
+        str: The name of the library
+    """
+    # On macos and windows, dynamic/static libraries always end with the
+    # extension and potential versions will be before the extension, and should
+    # be part of the library name.
+    # On linux, the version usually comes after the extension.
+    # So regardless of the platform we want to find the extension and make
+    # everything left to it the library name.
+
+    # Search for the extension - starting from the right - by removing any
+    # trailing digit.
+    comps = lib.basename.split(".")
+    for comp in reversed(comps):
+        if comp.isdigit():
+            comps.pop()
+        else:
+            break
+
+    # The library name is now everything minus the extension.
+    libname = ".".join(comps[:-1])
+
+    if libname.startswith("lib"):
+        return libname[3:]
+    else:
+        return libname
+
+def abs(value):
+    """Returns the absolute value of a number.
+
+    Args:
+      value (int): A number.
+
+    Returns:
+      int: The absolute value of the number.
+    """
+    if value < 0:
+        return -value
+    return value
+
+def determine_output_hash(crate_root, label):
+    """Generates a hash of the crate root file's path.
+
+    Args:
+        crate_root (File): The crate's root file (typically `lib.rs`).
+        label (Label): The label of the target.
+
+    Returns:
+        str: A string representation of the hash.
+    """
+
+    # Take the absolute value of hash() since it could be negative.
+    h = abs(hash(crate_root.path) + hash(repr(label)))
+    return repr(h)
+
+def get_preferred_artifact(library_to_link, use_pic):
+    """Get the first available library to link from a LibraryToLink object.
+
+    Args:
+        library_to_link (LibraryToLink): See the followg links for additional details:
+            https://docs.bazel.build/versions/master/skylark/lib/LibraryToLink.html
+        use_pic: If set, prefers pic_static_library over static_library.
+
+    Returns:
+        File: Returns the first valid library type (only one is expected)
+    """
+    if use_pic:
+        return (
+            library_to_link.pic_static_library or
+            library_to_link.interface_library or
+            library_to_link.dynamic_library
+        )
+    else:
+        return (
+            library_to_link.static_library or
+            library_to_link.pic_static_library or
+            library_to_link.interface_library or
+            library_to_link.dynamic_library
+        )
+
+def _expand_location(ctx, env, data):
+    """A trivial helper for `_expand_locations`
+
+    Args:
+        ctx (ctx): The rule's context object
+        env (str): The value possibly containing location macros to expand.
+        data (sequence of Targets): see `_expand_locations`
+
+    Returns:
+        string: The location-macro expanded version of the string.
+    """
+    for directive in ("$(execpath ", "$(location "):
+        if directive in env:
+            # build script runner will expand pwd to execroot for us
+            env = env.replace(directive, "${pwd}/" + directive)
+    return ctx.expand_location(env, data)
+
+def expand_dict_value_locations(ctx, env, data):
+    """Performs location-macro expansion on string values.
+
+    $(execroot ...) and $(location ...) are prefixed with ${pwd},
+    which process_wrapper and build_script_runner will expand at run time
+    to the absolute path. This is necessary because include_str!() is relative
+    to the currently compiled file, and build scripts run relative to the
+    manifest dir, so we can not use execroot-relative paths.
+
+    $(rootpath ...) is unmodified, and is useful for passing in paths via
+    rustc_env that are encoded in the binary with env!(), but utilized at
+    runtime, such as in tests. The absolute paths are not usable in this case,
+    as compilation happens in a separate sandbox folder, so when it comes time
+    to read the file at runtime, the path is no longer valid.
+
+    See [`expand_location`](https://docs.bazel.build/versions/main/skylark/lib/ctx.html#expand_location) for detailed documentation.
+
+    Args:
+        ctx (ctx): The rule's context object
+        env (dict): A dict whose values we iterate over
+        data (sequence of Targets): The targets which may be referenced by
+            location macros. This is expected to be the `data` attribute of
+            the target, though may have other targets or attributes mixed in.
+
+    Returns:
+        dict: A dict of environment variables with expanded location macros
+    """
+    return dict([(k, _expand_location(ctx, v, data)) for (k, v) in env.items()])
+
+def expand_list_element_locations(ctx, args, data):
+    """Performs location-macro expansion on a list of string values.
+
+    $(execroot ...) and $(location ...) are prefixed with ${pwd},
+    which process_wrapper and build_script_runner will expand at run time
+    to the absolute path.
+
+    See [`expand_location`](https://docs.bazel.build/versions/main/skylark/lib/ctx.html#expand_location) for detailed documentation.
+
+    Args:
+        ctx (ctx): The rule's context object
+        args (list): A list we iterate over
+        data (sequence of Targets): The targets which may be referenced by
+            location macros. This is expected to be the `data` attribute of
+            the target, though may have other targets or attributes mixed in.
+
+    Returns:
+        list: A list of arguments with expanded location macros
+    """
+    return [_expand_location(ctx, arg, data) for arg in args]
+
+def name_to_crate_name(name):
+    """Converts a build target's name into the name of its associated crate.
+
+    Crate names cannot contain certain characters, such as -, which are allowed
+    in build target names. All illegal characters will be converted to
+    underscores.
+
+    This is a similar conversion as that which cargo does, taking a
+    `Cargo.toml`'s `package.name` and canonicalizing it
+
+    Note that targets can specify the `crate_name` attribute to customize their
+    crate name; in situations where this is important, use the
+    compute_crate_name() function instead.
+
+    Args:
+        name (str): The name of the target.
+
+    Returns:
+        str: The name of the crate for this target.
+    """
+    return name.replace("-", "_")
+
+def _invalid_chars_in_crate_name(name):
+    """Returns any invalid chars in the given crate name.
+
+    Args:
+        name (str): Name to test.
+
+    Returns:
+        list: List of invalid characters in the crate name.
+    """
+
+    return dict([(c, ()) for c in name.elems() if not (c.isalnum() or c == "_")]).keys()
+
+def compute_crate_name(workspace_name, label, toolchain, name_override = None):
+    """Returns the crate name to use for the current target.
+
+    Args:
+        workspace_name (string): The current workspace name.
+        label (struct): The label of the current target.
+        toolchain (struct): The toolchain in use for the target.
+        name_override (String): An optional name to use (as an override of label.name).
+
+    Returns:
+        str: The crate name to use for this target.
+    """
+    if name_override:
+        invalid_chars = _invalid_chars_in_crate_name(name_override)
+        if invalid_chars:
+            fail("Crate name '{}' contains invalid character(s): {}".format(
+                name_override,
+                " ".join(invalid_chars),
+            ))
+        return name_override
+
+    if (toolchain and label and toolchain._rename_first_party_crates and
+        should_encode_label_in_crate_name(workspace_name, label, toolchain._third_party_dir)):
+        crate_name = encode_label_as_crate_name(label.package, label.name)
+    else:
+        crate_name = name_to_crate_name(label.name)
+
+    invalid_chars = _invalid_chars_in_crate_name(crate_name)
+    if invalid_chars:
+        fail(
+            "Crate name '{}' ".format(crate_name) +
+            "derived from Bazel target name '{}' ".format(label.name) +
+            "contains invalid character(s): {}\n".format(" ".join(invalid_chars)) +
+            "Consider adding a crate_name attribute to set a valid crate name",
+        )
+    return crate_name
+
+def dedent(doc_string):
+    """Remove any common leading whitespace from every line in text.
+
+    This functionality is similar to python's `textwrap.dedent` functionality
+    https://docs.python.org/3/library/textwrap.html#textwrap.dedent
+
+    Args:
+        doc_string (str): A docstring style string
+
+    Returns:
+        str: A string optimized for stardoc rendering
+    """
+    lines = doc_string.splitlines()
+    if not lines:
+        return doc_string
+
+    # If the first line is empty, use the second line
+    first_line = lines[0]
+    if not first_line:
+        first_line = lines[1]
+
+    # Detect how much space prepends the first line and subtract that from all lines
+    space_count = len(first_line) - len(first_line.lstrip())
+
+    # If there are no leading spaces, do not alter the docstring
+    if space_count == 0:
+        return doc_string
+    else:
+        # Remove the leading block of spaces from the current line
+        block = " " * space_count
+        return "\n".join([line.replace(block, "", 1).rstrip() for line in lines])
+
+def make_static_lib_symlink(actions, rlib_file):
+    """Add a .a symlink to an .rlib file.
+
+    The name of the symlink is derived from the <name> of the <name>.rlib file as follows:
+    * `<name>.a`, if <name> starts with `lib`
+    * `lib<name>.a`, otherwise.
+
+    For example, the name of the symlink for
+    * `libcratea.rlib` is `libcratea.a`
+    * `crateb.rlib` is `libcrateb.a`.
+
+    Args:
+        actions (actions): The rule's context actions object.
+        rlib_file (File): The file to symlink, which must end in .rlib.
+
+    Returns:
+        The symlink's File.
+    """
+    if not rlib_file.basename.endswith(".rlib"):
+        fail("file is not an .rlib: ", rlib_file.basename)
+    basename = rlib_file.basename[:-5]
+    if not basename.startswith("lib"):
+        basename = "lib" + basename
+    dot_a = actions.declare_file(basename + ".a", sibling = rlib_file)
+    actions.symlink(output = dot_a, target_file = rlib_file)
+    return dot_a
+
+def is_exec_configuration(ctx):
+    """Determine if a context is building for the exec configuration.
+
+    This is helpful when processing command line flags that should apply
+    to the target configuration but not the exec configuration.
+
+    Args:
+        ctx (ctx): The ctx object for the current target.
+
+    Returns:
+        True if the exec configuration is detected, False otherwise.
+    """
+
+    # TODO(djmarcin): Is there any better way to determine cfg=exec?
+    return ctx.genfiles_dir.path.find("-exec-") != -1
+
+def transform_deps(deps):
+    """Transforms a [Target] into [DepVariantInfo].
+
+    This helper function is used to transform ctx.attr.deps and ctx.attr.proc_macro_deps into
+    [DepVariantInfo].
+
+    Args:
+        deps (list of Targets): Dependencies coming from ctx.attr.deps or ctx.attr.proc_macro_deps
+
+    Returns:
+        list of DepVariantInfos.
+    """
+    return [DepVariantInfo(
+        crate_info = dep[CrateInfo] if CrateInfo in dep else None,
+        dep_info = dep[DepInfo] if DepInfo in dep else None,
+        build_info = dep[BuildInfo] if BuildInfo in dep else None,
+        cc_info = dep[CcInfo] if CcInfo in dep else None,
+    ) for dep in deps]
+
+def get_import_macro_deps(ctx):
+    """Returns a list of targets to be added to proc_macro_deps.
+
+    Args:
+        ctx (struct): the ctx of the current target.
+
+    Returns:
+        list of Targets. Either empty (if the fake import macro implementation
+        is being used), or a singleton list with the real implementation.
+    """
+    if ctx.attr._import_macro_dep.label.name == "fake_import_macro_impl":
+        return []
+
+    return [ctx.attr._import_macro_dep]
+
+def should_encode_label_in_crate_name(workspace_name, label, third_party_dir):
+    """Determines if the crate's name should include the Bazel label, encoded.
+
+    Crate names may only encode the label if the target is in the current repo,
+    the target is not in the third_party_dir, and the current repo is not
+    rules_rust.
+
+    Args:
+        workspace_name (string): The name of the current workspace.
+        label (Label): The package in question.
+        third_party_dir (string): The directory in which third-party packages are kept.
+
+    Returns:
+        True if the crate name should encode the label, False otherwise.
+    """
+
+    # TODO(hlopko): This code assumes a monorepo; make it work with external
+    # repositories as well.
+    return (
+        workspace_name != "rules_rust" and
+        not label.workspace_root and
+        not ("//" + label.package + "/").startswith(third_party_dir + "/")
+    )
+
+# This is a list of pairs, where the first element of the pair is a character
+# that is allowed in Bazel package or target names but not in crate names; and
+# the second element is an encoding of that char suitable for use in a crate
+# name.
+_encodings = (
+    (":", "colon"),
+    ("!", "bang"),
+    ("%", "percent"),
+    ("@", "at"),
+    ("^", "caret"),
+    ("`", "backtick"),
+    (" ", "space"),
+    ("\"", "quote"),
+    ("#", "hash"),
+    ("$", "dollar"),
+    ("&", "ampersand"),
+    ("'", "backslash"),
+    ("(", "lparen"),
+    (")", "rparen"),
+    ("*", "star"),
+    ("-", "dash"),
+    ("+", "plus"),
+    (",", "comma"),
+    (";", "semicolon"),
+    ("<", "langle"),
+    ("=", "equal"),
+    (">", "rangle"),
+    ("?", "question"),
+    ("[", "lbracket"),
+    ("]", "rbracket"),
+    ("{", "lbrace"),
+    ("|", "pipe"),
+    ("}", "rbrace"),
+    ("~", "tilde"),
+    ("/", "slash"),
+    (".", "dot"),
+)
+
+# For each of the above encodings, we generate two substitution rules: one that
+# ensures any occurrences of the encodings themselves in the package/target
+# aren't clobbered by this translation, and one that does the encoding itself.
+# We also include a rule that protects the clobbering-protection rules from
+# getting clobbered.
+_substitutions = [("_quote", "_quotequote_")] + [
+    subst
+    for (pattern, replacement) in _encodings
+    for subst in (
+        ("_{}_".format(replacement), "_quote{}_".format(replacement)),
+        (pattern, "_{}_".format(replacement)),
+    )
+]
+
+def encode_label_as_crate_name(package, name):
+    """Encodes the package and target names in a format suitable for a crate name.
+
+    Args:
+        package (string): The package of the target in question.
+        name (string): The name of the target in question.
+
+    Returns:
+        A string that encodes the package and target name, to be used as the crate's name.
+    """
+    full_name = package + ":" + name
+    return _replace_all(full_name, _substitutions)
+
+def decode_crate_name_as_label_for_testing(crate_name):
+    """Decodes a crate_name that was encoded by encode_label_as_crate_name.
+
+    This is used to check that the encoding is bijective; it is expected to only
+    be used in tests.
+
+    Args:
+        crate_name (string): The name of the crate.
+
+    Returns:
+        A string representing the Bazel label (package and target).
+    """
+    return _replace_all(crate_name, [(t[1], t[0]) for t in _substitutions])
+
+def _replace_all(string, substitutions):
+    """Replaces occurrences of the given patterns in `string`.
+
+    There are a few reasons this looks complicated:
+    * The substitutions are performed with some priority, i.e. patterns that are
+      listed first in `substitutions` are higher priority than patterns that are
+      listed later.
+    * We also take pains to avoid doing replacements that overlap with each
+      other, since overlaps invalidate pattern matches.
+    * To avoid hairy offset invalidation, we apply the substitutions
+      right-to-left.
+    * To avoid the "_quote" -> "_quotequote_" rule introducing new pattern
+      matches later in the string during decoding, we take the leftmost
+      replacement, in cases of overlap.  (Note that no rule can induce new
+      pattern matches *earlier* in the string.) (E.g. "_quotedot_" encodes to
+      "_quotequote_dot_". Note that "_quotequote_" and "_dot_" both occur in
+      this string, and overlap.).
+
+    Args:
+        string (string): the string in which the replacements should be performed.
+        substitutions: the list of patterns and replacements to apply.
+
+    Returns:
+        A string with the appropriate substitutions performed.
+    """
+
+    # Find the highest-priority pattern matches for each string index, going
+    # left-to-right and skipping indices that are already involved in a
+    # pattern match.
+    plan = {}
+    matched_indices_set = {}
+    for pattern_start in range(len(string)):
+        if pattern_start in matched_indices_set:
+            continue
+        for (pattern, replacement) in substitutions:
+            if not string.startswith(pattern, pattern_start):
+                continue
+            length = len(pattern)
+            plan[pattern_start] = (length, replacement)
+            matched_indices_set.update([(pattern_start + i, True) for i in range(length)])
+            break
+
+    # Execute the replacement plan, working from right to left.
+    for pattern_start in sorted(plan.keys(), reverse = True):
+        length, replacement = plan[pattern_start]
+        after_pattern = pattern_start + length
+        string = string[:pattern_start] + replacement + string[after_pattern:]
+
+    return string
diff --git a/third_party/rules_rust/rust/repositories.bzl b/third_party/rules_rust/rust/repositories.bzl
new file mode 100644
index 0000000..99f2f51
--- /dev/null
+++ b/third_party/rules_rust/rust/repositories.bzl
@@ -0,0 +1,368 @@
+# buildifier: disable=module-docstring
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//rust/private:common.bzl", "rust_common")
+load(
+    "//rust/private:repository_utils.bzl",
+    "BUILD_for_toolchain",
+    "DEFAULT_STATIC_RUST_URL_TEMPLATES",
+    "DEFAULT_TOOLCHAIN_NAME_PREFIX",
+    "check_version_valid",
+    "load_llvm_tools",
+    "load_rust_compiler",
+    "load_rust_src",
+    "load_rust_stdlib",
+    "load_rustc_dev_nightly",
+    "load_rustfmt",
+    "should_include_rustc_srcs",
+    _load_arbitrary_tool = "load_arbitrary_tool",
+)
+
+# Reexport `load_arbitrary_tool` as it's currently in use in https://github.com/google/cargo-raze
+load_arbitrary_tool = _load_arbitrary_tool
+
+# Note: Code in `.github/workflows/crate_universe.yaml` looks for this line, if you remove it or change its format, you will also need to update that code.
+DEFAULT_TOOLCHAIN_TRIPLES = {
+    "aarch64-apple-darwin": "rust_darwin_aarch64",
+    "aarch64-unknown-linux-gnu": "rust_linux_aarch64",
+    "x86_64-apple-darwin": "rust_darwin_x86_64",
+    "x86_64-pc-windows-msvc": "rust_windows_x86_64",
+    "x86_64-unknown-freebsd": "rust_freebsd_x86_64",
+    "x86_64-unknown-linux-gnu": "rust_linux_x86_64",
+}
+
+def rules_rust_dependencies():
+    """Dependencies used in the implementation of `rules_rust`."""
+    maybe(
+        http_archive,
+        name = "rules_cc",
+        urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.1/rules_cc-0.0.1.tar.gz"],
+        sha256 = "4dccbfd22c0def164c8f47458bd50e0c7148f3d92002cdb459c2a96a68498241",
+    )
+
+    maybe(
+        http_archive,
+        name = "bazel_skylib",
+        urls = [
+            "https://github.com/bazelbuild/bazel-skylib/releases/download/1.2.0/bazel-skylib-1.2.0.tar.gz",
+            "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.2.0/bazel-skylib-1.2.0.tar.gz",
+        ],
+        sha256 = "af87959afe497dc8dfd4c6cb66e1279cb98ccc84284619ebfec27d9c09a903de",
+    )
+
+    # Make the iOS simulator constraint available, which is referenced in abi_to_constraints()
+    # rules_rust does not require this dependency; it is just imported as a convenience for users.
+    maybe(
+        http_archive,
+        name = "build_bazel_apple_support",
+        sha256 = "76df040ade90836ff5543888d64616e7ba6c3a7b33b916aa3a4b68f342d1b447",
+        url = "https://github.com/bazelbuild/apple_support/releases/download/0.11.0/apple_support.0.11.0.tar.gz",
+    )
+
+# buildifier: disable=unnamed-macro
+def rust_register_toolchains(
+        dev_components = False,
+        edition = None,
+        include_rustc_srcs = False,
+        iso_date = None,
+        register_toolchains = True,
+        rustfmt_version = None,
+        sha256s = None,
+        extra_target_triples = ["wasm32-unknown-unknown", "wasm32-wasi"],
+        urls = DEFAULT_STATIC_RUST_URL_TEMPLATES,
+        version = rust_common.default_version):
+    """Emits a default set of toolchains for Linux, MacOS, and Freebsd
+
+    Skip this macro and call the `rust_repository_set` macros directly if you need a compiler for \
+    other hosts or for additional target triples.
+
+    The `sha256` attribute represents a dict associating tool subdirectories to sha256 hashes. As an example:
+    ```python
+    {
+        "rust-1.46.0-x86_64-unknown-linux-gnu": "e3b98bc3440fe92817881933f9564389eccb396f5f431f33d48b979fa2fbdcf5",
+        "rustfmt-1.4.12-x86_64-unknown-linux-gnu": "1894e76913303d66bf40885a601462844eec15fca9e76a6d13c390d7000d64b0",
+        "rust-std-1.46.0-x86_64-unknown-linux-gnu": "ac04aef80423f612c0079829b504902de27a6997214eb58ab0765d02f7ec1dbc",
+    }
+    ```
+    This would match for `exec_triple = "x86_64-unknown-linux-gnu"`.  If not specified, rules_rust pulls from a non-exhaustive \
+    list of known checksums..
+
+    See `load_arbitrary_tool` in `@rules_rust//rust:repositories.bzl` for more details.
+
+    Args:
+        dev_components (bool, optional): Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly".
+        edition (str, optional): The rust edition to be used by default (2015, 2018 (default), or 2021)
+        include_rustc_srcs (bool, optional): Whether to download rustc's src code. This is required in order to use rust-analyzer support.
+            See [rust_toolchain_repository.include_rustc_srcs](#rust_toolchain_repository-include_rustc_srcs). for more details
+        iso_date (str, optional): The date of the nightly or beta release (ignored if the version is a specific version).
+        register_toolchains (bool): If true, repositories will be generated to produce and register `rust_toolchain` targets.
+        rustfmt_version (str, optional): The version of rustfmt. Either "nightly", "beta", or an exact version. Defaults to `version` if not specified.
+        sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes.
+        extra_target_triples (list, optional): Additional rust-style targets that rust toolchains should support.
+        urls (list, optional): A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format).
+        version (str, optional): The version of Rust. Either "nightly", "beta", or an exact version. Defaults to a modern version.
+    """
+    if dev_components and version != "nightly":
+        fail("Rust version must be set to \"nightly\" to enable rustc-dev components")
+
+    if not rustfmt_version:
+        rustfmt_version = version
+
+    for exec_triple, name in DEFAULT_TOOLCHAIN_TRIPLES.items():
+        maybe(
+            rust_repository_set,
+            name = name,
+            dev_components = dev_components,
+            edition = edition,
+            exec_triple = exec_triple,
+            extra_target_triples = extra_target_triples,
+            include_rustc_srcs = include_rustc_srcs,
+            iso_date = iso_date,
+            register_toolchain = register_toolchains,
+            rustfmt_version = rustfmt_version,
+            sha256s = sha256s,
+            urls = urls,
+            version = version,
+        )
+
+# buildifier: disable=unnamed-macro
+def rust_repositories(**kwargs):
+    """**Deprecated**: Use [rules_rust_dependencies](#rules_rust_dependencies) \
+    and [rust_register_toolchains](#rust_register_toolchains) directly.
+
+    Args:
+        **kwargs (dict): Keyword arguments for the `rust_register_toolchains` macro.
+    """
+    rules_rust_dependencies()
+
+    rust_register_toolchains(**kwargs)
+
+def _rust_toolchain_repository_impl(ctx):
+    """The implementation of the rust toolchain repository rule."""
+
+    check_version_valid(ctx.attr.version, ctx.attr.iso_date)
+
+    # Conditionally download rustc sources. Generally used for `rust-analyzer`
+    if should_include_rustc_srcs(ctx):
+        load_rust_src(ctx)
+
+    build_components = [load_rust_compiler(ctx)]
+
+    if ctx.attr.rustfmt_version:
+        build_components.append(load_rustfmt(ctx))
+
+    # Rust 1.45.0 and nightly builds after 2020-05-22 need the llvm-tools gzip to get the libLLVM dylib
+    if ctx.attr.version >= "1.45.0" or (ctx.attr.version == "nightly" and ctx.attr.iso_date > "2020-05-22"):
+        load_llvm_tools(ctx, ctx.attr.exec_triple)
+
+    for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
+        build_components.append(load_rust_stdlib(ctx, target_triple))
+
+        # extra_target_triples contains targets such as wasm, which don't have rustc_dev components
+        if ctx.attr.dev_components and target_triple not in ctx.attr.extra_target_triples:
+            load_rustc_dev_nightly(ctx, target_triple)
+
+    ctx.file("WORKSPACE.bazel", "")
+    ctx.file("BUILD.bazel", "\n".join(build_components))
+
+def _rust_toolchain_repository_proxy_impl(ctx):
+    build_components = []
+    for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
+        build_components.append(BUILD_for_toolchain(
+            name = "{toolchain_prefix}_{target_triple}".format(
+                toolchain_prefix = ctx.attr.toolchain_name_prefix,
+                target_triple = target_triple,
+            ),
+            exec_triple = ctx.attr.exec_triple,
+            parent_workspace_name = ctx.attr.parent_workspace_name,
+            target_triple = target_triple,
+        ))
+
+    ctx.file("WORKSPACE.bazel", "")
+    ctx.file("BUILD.bazel", "\n".join(build_components))
+
+rust_toolchain_repository = repository_rule(
+    doc = (
+        "Composes a single workspace containing the toolchain components for compiling on a given " +
+        "platform to a series of target platforms.\n" +
+        "\n" +
+        "A given instance of this rule should be accompanied by a rust_toolchain_repository_proxy " +
+        "invocation to declare its toolchains to Bazel; the indirection allows separating toolchain " +
+        "selection from toolchain fetching."
+    ),
+    attrs = {
+        "auth": attr.string_dict(
+            doc = (
+                "Auth object compatible with repository_ctx.download to use when downloading files. " +
+                "See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details."
+            ),
+        ),
+        "dev_components": attr.bool(
+            doc = "Whether to download the rustc-dev components (defaults to False). Requires version to be \"nightly\".",
+            default = False,
+        ),
+        "edition": attr.string(
+            doc = "The rust edition to be used by default.",
+            default = rust_common.default_edition,
+        ),
+        "exec_triple": attr.string(
+            doc = "The Rust-style target that this compiler runs on",
+            mandatory = True,
+        ),
+        "extra_target_triples": attr.string_list(
+            doc = "Additional rust-style targets that this set of toolchains should support.",
+        ),
+        "include_rustc_srcs": attr.bool(
+            doc = (
+                "Whether to download and unpack the rustc source files. These are very large, and " +
+                "slow to unpack, but are required to support rust analyzer. An environment variable " +
+                "`RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS` can also be used to control this attribute. " +
+                "This variable will take precedence over the hard coded attribute. Setting it to `true` to " +
+                "activates this attribute where all other values deactivate it."
+            ),
+            default = False,
+        ),
+        "iso_date": attr.string(
+            doc = "The date of the tool (or None, if the version is a specific version).",
+        ),
+        "rustfmt_version": attr.string(
+            doc = "The version of the tool among \"nightly\", \"beta\", or an exact version.",
+        ),
+        "sha256s": attr.string_dict(
+            doc = "A dict associating tool subdirectories to sha256 hashes. See [rust_repositories](#rust_repositories) for more details.",
+        ),
+        "toolchain_name_prefix": attr.string(
+            doc = "The per-target prefix expected for the rust_toolchain declarations in the parent workspace.",
+        ),
+        "urls": attr.string_list(
+            doc = "A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format).",
+            default = DEFAULT_STATIC_RUST_URL_TEMPLATES,
+        ),
+        "version": attr.string(
+            doc = "The version of the tool among \"nightly\", \"beta\", or an exact version.",
+            mandatory = True,
+        ),
+    },
+    implementation = _rust_toolchain_repository_impl,
+    environ = ["RULES_RUST_TOOLCHAIN_INCLUDE_RUSTC_SRCS"],
+)
+
+rust_toolchain_repository_proxy = repository_rule(
+    doc = (
+        "Generates a toolchain-bearing repository that declares the toolchains from some other " +
+        "rust_toolchain_repository."
+    ),
+    attrs = {
+        "exec_triple": attr.string(
+            doc = "The Rust-style target triple for the compilation platform",
+            mandatory = True,
+        ),
+        "extra_target_triples": attr.string_list(
+            doc = "The Rust-style triples for extra compilation targets",
+        ),
+        "parent_workspace_name": attr.string(
+            doc = "The name of the other rust_toolchain_repository",
+            mandatory = True,
+        ),
+        "toolchain_name_prefix": attr.string(
+            doc = "The per-target prefix expected for the rust_toolchain declarations in the parent workspace.",
+        ),
+    },
+    implementation = _rust_toolchain_repository_proxy_impl,
+)
+
+def rust_repository_set(
+        name,
+        version,
+        exec_triple,
+        include_rustc_srcs = False,
+        extra_target_triples = [],
+        iso_date = None,
+        rustfmt_version = None,
+        edition = None,
+        dev_components = False,
+        sha256s = None,
+        urls = DEFAULT_STATIC_RUST_URL_TEMPLATES,
+        auth = None,
+        register_toolchain = True):
+    """Assembles a remote repository for the given toolchain params, produces a proxy repository \
+    to contain the toolchain declaration, and registers the toolchains.
+
+    N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints) \
+    without actually downloading the toolchain.
+
+    Args:
+        name (str): The name of the generated repository
+        version (str): The version of the tool among "nightly", "beta', or an exact version.
+        exec_triple (str): The Rust-style target that this compiler runs on
+        include_rustc_srcs (bool, optional): Whether to download rustc's src code. This is required in order to use rust-analyzer support. Defaults to False.
+        extra_target_triples (list, optional): Additional rust-style targets that this set of
+            toolchains should support. Defaults to [].
+        iso_date (str, optional): The date of the tool. Defaults to None.
+        rustfmt_version (str, optional):  The version of rustfmt to be associated with the
+            toolchain. Defaults to None.
+        edition (str, optional): The rust edition to be used by default (2015, 2018 (if None), or 2021).
+        dev_components (bool, optional): Whether to download the rustc-dev components.
+            Requires version to be "nightly". Defaults to False.
+        sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. See
+            [rust_repositories](#rust_repositories) for more details.
+        urls (list, optional): A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). Defaults to ['https://static.rust-lang.org/dist/{}.tar.gz']
+        auth (dict): Auth object compatible with repository_ctx.download to use when downloading files.
+            See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details.
+        register_toolchain (bool): If True, the generated `rust_toolchain` target will become a registered toolchain.
+    """
+
+    rust_toolchain_repository(
+        name = name,
+        exec_triple = exec_triple,
+        include_rustc_srcs = include_rustc_srcs,
+        extra_target_triples = extra_target_triples,
+        iso_date = iso_date,
+        toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
+        version = version,
+        rustfmt_version = rustfmt_version,
+        edition = edition,
+        dev_components = dev_components,
+        sha256s = sha256s,
+        urls = urls,
+        auth = auth,
+    )
+
+    rust_toolchain_repository_proxy(
+        name = name + "_toolchains",
+        exec_triple = exec_triple,
+        extra_target_triples = extra_target_triples,
+        parent_workspace_name = name,
+        toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
+    )
+
+    all_toolchain_names = []
+    for target_triple in [exec_triple] + extra_target_triples:
+        all_toolchain_names.append("@{name}_toolchains//:{toolchain_name_prefix}_{triple}".format(
+            name = name,
+            toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
+            triple = target_triple,
+        ))
+
+    # Register toolchains
+    if register_toolchain:
+        native.register_toolchains(*all_toolchain_names)
+        native.register_toolchains(str(Label("//rust/private/dummy_cc_toolchain:dummy_cc_wasm32_toolchain")))
+
+    # Inform users that they should be using the canonical name if it's not detected
+    if "rules_rust" not in native.existing_rules():
+        message = "\n" + ("=" * 79) + "\n"
+        message += (
+            "It appears that you are trying to import rules_rust without using its\n" +
+            "canonical name, \"@rules_rust\" Please change your WORKSPACE file to\n" +
+            "import this repo with `name = \"rules_rust\"` instead."
+        )
+
+        if "io_bazel_rules_rust" in native.existing_rules():
+            message += "\n\n" + (
+                "Note that the previous name of \"@io_bazel_rules_rust\" is deprecated.\n" +
+                "See https://github.com/bazelbuild/rules_rust/issues/499 for context."
+            )
+
+        message += "\n" + ("=" * 79)
+        fail(message)
diff --git a/third_party/rules_rust/rust/rust_common.bzl b/third_party/rules_rust/rust/rust_common.bzl
new file mode 100644
index 0000000..4777ba1
--- /dev/null
+++ b/third_party/rules_rust/rust/rust_common.bzl
@@ -0,0 +1,20 @@
+# Copyright 2015 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Module with Rust definitions required to write custom Rust rules."""
+
+load("//rust/private:providers.bzl", _ClippyInfo = "ClippyInfo", _CrateInfo = "CrateInfo")
+
+CrateInfo = _CrateInfo
+ClippyInfo = _ClippyInfo
diff --git a/third_party/rules_rust/rust/settings/BUILD.bazel b/third_party/rules_rust/rust/settings/BUILD.bazel
new file mode 100644
index 0000000..474237a
--- /dev/null
+++ b/third_party/rules_rust/rust/settings/BUILD.bazel
@@ -0,0 +1,49 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag", "string_flag")
+
+package(default_visibility = ["//visibility:public"])
+
+# A flag controlling whether to rename first-party crates such that their names
+# encode the Bazel package and target name, instead of just the target name.
+#
+# First-party vs. third-party crates are identified using the value of
+# //settings:third_party_dir.
+bool_flag(
+    name = "rename_first_party_crates",
+    build_setting_default = False,
+)
+
+# A flag specifying the location of vendored third-party rust crates within this
+# repository that must not be renamed when `rename_first_party_crates` is enabled.
+#
+# Must be specified as a Bazel package, e.g. "//some/location/in/repo".
+string_flag(
+    name = "third_party_dir",
+    build_setting_default = "//third_party/rust",
+)
+
+# A flag to control whether rust_library and rust_binary targets should
+# implicitly depend on the *real* import macro, or on a no-op target.
+bool_flag(
+    name = "use_real_import_macro",
+    build_setting_default = False,
+)
+
+# A flag that enables/disables the use of process_wrapper when invoking rustc.
+# This is useful for building process_wrapper itself without causing dependency cycles.
+bool_flag(
+    name = "use_process_wrapper",
+    build_setting_default = True,
+)
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]),
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//settings:bzl_lib` target instead",
+    visibility = ["//rust:__subpackages__"],
+)
diff --git a/third_party/rules_rust/rust/settings/incompatible.bzl b/third_party/rules_rust/rust/settings/incompatible.bzl
new file mode 100644
index 0000000..d1d3f16
--- /dev/null
+++ b/third_party/rules_rust/rust/settings/incompatible.bzl
@@ -0,0 +1,27 @@
+"""This file contains definitions of all current incompatible flags.
+
+See COMPATIBILITY.md for the backwards compatibility policy.
+"""
+
+IncompatibleFlagInfo = provider(
+    doc = "Provider for the current value of an incompatible flag.",
+    fields = {
+        "enabled": "(bool) whether the flag is enabled",
+        "issue": "(string) link to the github issue associated with this flag",
+    },
+)
+
+def _incompatible_flag_impl(ctx):
+    return [IncompatibleFlagInfo(enabled = ctx.build_setting_value, issue = ctx.attr.issue)]
+
+incompatible_flag = rule(
+    doc = "A rule defining an incompatible flag.",
+    implementation = _incompatible_flag_impl,
+    build_setting = config.bool(flag = True),
+    attrs = {
+        "issue": attr.string(
+            doc = "The link to the github issue associated with this flag",
+            mandatory = True,
+        ),
+    },
+)
diff --git a/third_party/rules_rust/rust/toolchain.bzl b/third_party/rules_rust/rust/toolchain.bzl
new file mode 100644
index 0000000..687e0df
--- /dev/null
+++ b/third_party/rules_rust/rust/toolchain.bzl
@@ -0,0 +1,662 @@
+"""The rust_toolchain rule definition and implementation."""
+
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
+load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:utils.bzl", "dedent", "find_cc_toolchain", "make_static_lib_symlink")
+
+def _rust_stdlib_filegroup_impl(ctx):
+    rust_std = ctx.files.srcs
+    dot_a_files = []
+    between_alloc_and_core_files = []
+    core_files = []
+    between_core_and_std_files = []
+    std_files = []
+    alloc_files = []
+    self_contained_files = [
+        file
+        for file in rust_std
+        if file.basename.endswith(".o") and "self-contained" in file.path
+    ]
+
+    std_rlibs = [f for f in rust_std if f.basename.endswith(".rlib")]
+    if std_rlibs:
+        # std depends on everything
+        #
+        # core only depends on alloc, but we poke adler in there
+        # because that needs to be before miniz_oxide
+        #
+        # alloc depends on the allocator_library if it's configured, but we
+        # do that later.
+        dot_a_files = [make_static_lib_symlink(ctx.actions, f) for f in std_rlibs]
+
+        alloc_files = [f for f in dot_a_files if "alloc" in f.basename and "std" not in f.basename]
+        between_alloc_and_core_files = [f for f in dot_a_files if "compiler_builtins" in f.basename]
+        core_files = [f for f in dot_a_files if ("core" in f.basename or "adler" in f.basename) and "std" not in f.basename]
+        between_core_and_std_files = [
+            f
+            for f in dot_a_files
+            if "alloc" not in f.basename and "compiler_builtins" not in f.basename and "core" not in f.basename and "adler" not in f.basename and "std" not in f.basename
+        ]
+        std_files = [f for f in dot_a_files if "std" in f.basename]
+
+        partitioned_files_len = len(alloc_files) + len(between_alloc_and_core_files) + len(core_files) + len(between_core_and_std_files) + len(std_files)
+        if partitioned_files_len != len(dot_a_files):
+            partitioned = alloc_files + between_alloc_and_core_files + core_files + between_core_and_std_files + std_files
+            for f in sorted(partitioned):
+                # buildifier: disable=print
+                print("File partitioned: {}".format(f.basename))
+            fail("rust_toolchain couldn't properly partition rlibs in rust_std. Partitioned {} out of {} files. This is probably a bug in the rule implementation.".format(partitioned_files_len, len(dot_a_files)))
+
+    return [
+        DefaultInfo(
+            files = depset(ctx.files.srcs),
+        ),
+        rust_common.stdlib_info(
+            std_rlibs = std_rlibs,
+            dot_a_files = dot_a_files,
+            between_alloc_and_core_files = between_alloc_and_core_files,
+            core_files = core_files,
+            between_core_and_std_files = between_core_and_std_files,
+            std_files = std_files,
+            alloc_files = alloc_files,
+            self_contained_files = self_contained_files,
+            srcs = ctx.attr.srcs,
+        ),
+    ]
+
+rust_stdlib_filegroup = rule(
+    doc = "A dedicated filegroup-like rule for Rust stdlib artifacts.",
+    implementation = _rust_stdlib_filegroup_impl,
+    attrs = {
+        "srcs": attr.label_list(
+            allow_files = True,
+            doc = "The list of targets/files that are components of the rust-stdlib file group",
+            mandatory = True,
+        ),
+    },
+)
+
+def _ltl(library, ctx, cc_toolchain, feature_configuration):
+    """A helper to generate `LibraryToLink` objects
+
+    Args:
+        library (File): A rust library file to link.
+        ctx (ctx): The rule's context object.
+        cc_toolchain (CcToolchainInfo): A cc toolchain provider to be used.
+        feature_configuration (feature_configuration): feature_configuration to be queried.
+
+    Returns:
+        LibraryToLink: A provider containing information about libraries to link.
+    """
+    return cc_common.create_library_to_link(
+        actions = ctx.actions,
+        feature_configuration = feature_configuration,
+        cc_toolchain = cc_toolchain,
+        static_library = library,
+        pic_static_library = library,
+    )
+
+def _make_libstd_and_allocator_ccinfo(ctx, rust_std, allocator_library):
+    """Make the CcInfo (if possible) for libstd and allocator libraries.
+
+    Args:
+        ctx (ctx): The rule's context object.
+        rust_std: The Rust standard library.
+        allocator_library: The target to use for providing allocator functions.
+
+
+    Returns:
+        A CcInfo object for the required libraries, or None if no such libraries are available.
+    """
+    cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
+    cc_infos = []
+
+    if not rust_common.stdlib_info in rust_std:
+        fail(dedent("""\
+            {} --
+            The `rust_lib` ({}) must be a target providing `rust_common.stdlib_info`
+            (typically `rust_stdlib_filegroup` rule from @rules_rust//rust:defs.bzl).
+            See https://github.com/bazelbuild/rules_rust/pull/802 for more information.
+        """).format(ctx.label, rust_std))
+    rust_stdlib_info = rust_std[rust_common.stdlib_info]
+
+    if rust_stdlib_info.self_contained_files:
+        compilation_outputs = cc_common.create_compilation_outputs(
+            objects = depset(rust_stdlib_info.self_contained_files),
+        )
+
+        linking_context, _linking_outputs = cc_common.create_linking_context_from_compilation_outputs(
+            name = ctx.label.name,
+            actions = ctx.actions,
+            feature_configuration = feature_configuration,
+            cc_toolchain = cc_toolchain,
+            compilation_outputs = compilation_outputs,
+        )
+
+        cc_infos.append(CcInfo(
+            linking_context = linking_context,
+        ))
+
+    if rust_stdlib_info.std_rlibs:
+        alloc_inputs = depset(
+            [_ltl(f, ctx, cc_toolchain, feature_configuration) for f in rust_stdlib_info.alloc_files],
+        )
+        between_alloc_and_core_inputs = depset(
+            [_ltl(f, ctx, cc_toolchain, feature_configuration) for f in rust_stdlib_info.between_alloc_and_core_files],
+            transitive = [alloc_inputs],
+            order = "topological",
+        )
+        core_inputs = depset(
+            [_ltl(f, ctx, cc_toolchain, feature_configuration) for f in rust_stdlib_info.core_files],
+            transitive = [between_alloc_and_core_inputs],
+            order = "topological",
+        )
+
+        # The libraries panic_abort and panic_unwind are alternatives.
+        # The std by default requires panic_unwind.
+        # Exclude panic_abort if panic_unwind is present.
+        # TODO: Provide a setting to choose between panic_abort and panic_unwind.
+        filtered_between_core_and_std_files = rust_stdlib_info.between_core_and_std_files
+        has_panic_unwind = [
+            f
+            for f in filtered_between_core_and_std_files
+            if "panic_unwind" in f.basename
+        ]
+        if has_panic_unwind:
+            filtered_between_core_and_std_files = [
+                f
+                for f in filtered_between_core_and_std_files
+                if "panic_abort" not in f.basename
+            ]
+        between_core_and_std_inputs = depset(
+            [
+                _ltl(f, ctx, cc_toolchain, feature_configuration)
+                for f in filtered_between_core_and_std_files
+            ],
+            transitive = [core_inputs],
+            order = "topological",
+        )
+        std_inputs = depset(
+            [
+                _ltl(f, ctx, cc_toolchain, feature_configuration)
+                for f in rust_stdlib_info.std_files
+            ],
+            transitive = [between_core_and_std_inputs],
+            order = "topological",
+        )
+
+        link_inputs = cc_common.create_linker_input(
+            owner = rust_std.label,
+            libraries = std_inputs,
+        )
+
+        allocator_inputs = None
+        if allocator_library:
+            allocator_inputs = [allocator_library[CcInfo].linking_context.linker_inputs]
+
+        cc_infos.append(CcInfo(
+            linking_context = cc_common.create_linking_context(
+                linker_inputs = depset(
+                    [link_inputs],
+                    transitive = allocator_inputs,
+                    order = "topological",
+                ),
+            ),
+        ))
+
+    if cc_infos:
+        return cc_common.merge_cc_infos(
+            direct_cc_infos = cc_infos,
+        )
+    return None
+
+def _symlink_sysroot_tree(ctx, name, target):
+    """Generate a set of symlinks to files from another target
+
+    Args:
+        ctx (ctx): The toolchain's context object
+        name (str): The name of the sysroot directory (typically `ctx.label.name`)
+        target (Target): A target owning files to symlink
+
+    Returns:
+        depset[File]: A depset of the generated symlink files
+    """
+    tree_files = []
+    for file in target.files.to_list():
+        # Parse the path to the file relative to the workspace root so a
+        # symlink matching this path can be created within the sysroot.
+
+        # The code blow attempts to parse any workspace names out of the
+        # path. For local targets, this code is a noop.
+        if target.label.workspace_root:
+            file_path = file.path.split(target.label.workspace_root, 1)[-1]
+        else:
+            file_path = file.path
+
+        symlink = ctx.actions.declare_file("{}/{}".format(name, file_path.lstrip("/")))
+
+        ctx.actions.symlink(
+            output = symlink,
+            target_file = file,
+        )
+
+        tree_files.append(symlink)
+
+    return depset(tree_files)
+
+def _symlink_sysroot_bin(ctx, name, directory, target):
+    """Crete a symlink to a target file.
+
+    Args:
+        ctx (ctx): The rule's context object
+        name (str): A common name for the output directory
+        directory (str): The directory under `name` to put the file in
+        target (File): A File object to symlink to
+
+    Returns:
+        File: A newly generated symlink file
+    """
+    symlink = ctx.actions.declare_file("{}/{}/{}".format(
+        name,
+        directory,
+        target.basename,
+    ))
+
+    ctx.actions.symlink(
+        output = symlink,
+        target_file = target,
+        is_executable = True,
+    )
+
+    return symlink
+
+def _generate_sysroot(
+        ctx,
+        rustc,
+        rustdoc,
+        rustc_lib,
+        cargo = None,
+        clippy = None,
+        llvm_tools = None,
+        rust_std = None,
+        rustfmt = None):
+    """Generate a rust sysroot from collection of toolchain components
+
+    Args:
+        ctx (ctx): A context object from a `rust_toolchain` rule.
+        rustc (File): The path to a `rustc` executable.
+        rustdoc (File): The path to a `rustdoc` executable.
+        rustc_lib (Target): A collection of Files containing dependencies of `rustc`.
+        cargo (File, optional): The path to a `cargo` executable.
+        clippy (File, optional): The path to a `clippy-driver` executable.
+        llvm_tools (Target, optional): A collection of llvm tools used by `rustc`.
+        rust_std (Target, optional): A collection of Files containing Rust standard library components.
+        rustfmt (File, optional): The path to a `rustfmt` executable.
+
+    Returns:
+        struct: A struct of generated files representing the new sysroot
+    """
+    name = ctx.label.name
+
+    # Define runfiles
+    direct_files = []
+    transitive_file_sets = []
+
+    # Rustc
+    sysroot_rustc = _symlink_sysroot_bin(ctx, name, "bin", rustc)
+    direct_files.extend([sysroot_rustc])
+
+    # Rustc dependencies
+    sysroot_rustc_lib = None
+    if rustc_lib:
+        sysroot_rustc_lib = _symlink_sysroot_tree(ctx, name, rustc_lib)
+        transitive_file_sets.extend([sysroot_rustc_lib])
+
+    # Rustdoc
+    sysroot_rustdoc = _symlink_sysroot_bin(ctx, name, "bin", rustdoc)
+    direct_files.extend([sysroot_rustdoc])
+
+    # Clippy
+    sysroot_clippy = None
+    if clippy:
+        sysroot_clippy = _symlink_sysroot_bin(ctx, name, "bin", clippy)
+        direct_files.extend([sysroot_clippy])
+
+    # Cargo
+    sysroot_cargo = None
+    if cargo:
+        sysroot_cargo = _symlink_sysroot_bin(ctx, name, "bin", cargo)
+        direct_files.extend([sysroot_cargo])
+
+    # Rustfmt
+    sysroot_rustfmt = None
+    if rustfmt:
+        sysroot_rustfmt = _symlink_sysroot_bin(ctx, name, "bin", rustfmt)
+        direct_files.extend([sysroot_rustfmt])
+
+    # Llvm tools
+    sysroot_llvm_tools = None
+    if llvm_tools:
+        sysroot_llvm_tools = _symlink_sysroot_tree(ctx, name, llvm_tools)
+        transitive_file_sets.extend([sysroot_llvm_tools])
+
+    # Rust standard library
+    sysroot_rust_std = None
+    if rust_std:
+        sysroot_rust_std = _symlink_sysroot_tree(ctx, name, rust_std)
+        transitive_file_sets.extend([sysroot_rust_std])
+
+    # Declare a file in the root of the sysroot to make locating the sysroot easy
+    sysroot_anchor = ctx.actions.declare_file("{}/rust.sysroot".format(name))
+    ctx.actions.write(
+        output = sysroot_anchor,
+        content = "\n".join([
+            "cargo: {}".format(cargo),
+            "clippy: {}".format(clippy),
+            "llvm_tools: {}".format(llvm_tools),
+            "rust_std: {}".format(rust_std),
+            "rustc_lib: {}".format(rustc_lib),
+            "rustc: {}".format(rustc),
+            "rustdoc: {}".format(rustdoc),
+            "rustfmt: {}".format(rustfmt),
+        ]),
+    )
+
+    # Create a depset of all sysroot files (symlinks and their real paths)
+    all_files = depset(direct_files, transitive = transitive_file_sets)
+
+    return struct(
+        all_files = all_files,
+        cargo = sysroot_cargo,
+        clippy = sysroot_clippy,
+        rust_std = sysroot_rust_std,
+        rustc = sysroot_rustc,
+        rustc_lib = sysroot_rustc_lib,
+        rustdoc = sysroot_rustdoc,
+        rustfmt = sysroot_rustfmt,
+        sysroot_anchor = sysroot_anchor,
+    )
+
+def _rust_toolchain_impl(ctx):
+    """The rust_toolchain implementation
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list containing the target's toolchain Provider info
+    """
+    compilation_mode_opts = {}
+    for k, v in ctx.attr.opt_level.items():
+        if not k in ctx.attr.debug_info:
+            fail("Compilation mode {} is not defined in debug_info but is defined opt_level".format(k))
+        compilation_mode_opts[k] = struct(debug_info = ctx.attr.debug_info[k], opt_level = v)
+    for k, v in ctx.attr.debug_info.items():
+        if not k in ctx.attr.opt_level:
+            fail("Compilation mode {} is not defined in opt_level but is defined debug_info".format(k))
+
+    if ctx.attr.target_triple and ctx.file.target_json:
+        fail("Do not specify both target_triple and target_json, either use a builtin triple or provide a custom specification file.")
+
+    rename_first_party_crates = ctx.attr._rename_first_party_crates[BuildSettingInfo].value
+    third_party_dir = ctx.attr._third_party_dir[BuildSettingInfo].value
+
+    if ctx.attr.rust_lib:
+        # buildifier: disable=print
+        print("`rust_toolchain.rust_lib` is deprecated. Please update {} to use `rust_toolchain.rust_std`".format(
+            ctx.label,
+        ))
+        rust_std = ctx.attr.rust_lib
+    else:
+        rust_std = ctx.attr.rust_std
+
+    sysroot = _generate_sysroot(
+        ctx = ctx,
+        rustc = ctx.file.rustc,
+        rustdoc = ctx.file.rust_doc,
+        rustc_lib = ctx.attr.rustc_lib,
+        rust_std = rust_std,
+        rustfmt = ctx.file.rustfmt,
+        clippy = ctx.file.clippy_driver,
+        cargo = ctx.file.cargo,
+        llvm_tools = ctx.attr.llvm_tools,
+    )
+
+    expanded_stdlib_linkflags = []
+    for flag in ctx.attr.stdlib_linkflags:
+        expanded_stdlib_linkflags.append(
+            ctx.expand_location(
+                flag,
+                targets = rust_std[rust_common.stdlib_info].srcs,
+            ),
+        )
+
+    linking_context = cc_common.create_linking_context(
+        linker_inputs = depset([
+            cc_common.create_linker_input(
+                owner = ctx.label,
+                user_link_flags = depset(expanded_stdlib_linkflags),
+            ),
+        ]),
+    )
+
+    # Contains linker flags needed to link Rust standard library.
+    # These need to be added to linker command lines when the linker is not rustc
+    # (rustc does this automatically). Linker flags wrapped in an otherwise empty
+    # `CcInfo` to provide the flags in a way that doesn't duplicate them per target
+    # providing a `CcInfo`.
+    stdlib_linkflags_cc_info = CcInfo(
+        compilation_context = cc_common.create_compilation_context(),
+        linking_context = linking_context,
+    )
+
+    # Determine the path and short_path of the sysroot
+    sysroot_path = sysroot.sysroot_anchor.dirname
+    sysroot_short_path, _, _ = sysroot.sysroot_anchor.short_path.rpartition("/")
+
+    toolchain = platform_common.ToolchainInfo(
+        all_files = sysroot.all_files,
+        binary_ext = ctx.attr.binary_ext,
+        cargo = sysroot.cargo,
+        clippy_driver = sysroot.clippy,
+        compilation_mode_opts = compilation_mode_opts,
+        crosstool_files = ctx.files._cc_toolchain,
+        default_edition = ctx.attr.default_edition,
+        dylib_ext = ctx.attr.dylib_ext,
+        exec_triple = ctx.attr.exec_triple,
+        libstd_and_allocator_ccinfo = _make_libstd_and_allocator_ccinfo(ctx, rust_std, ctx.attr.allocator_library),
+        os = ctx.attr.os,
+        rust_doc = sysroot.rustdoc,
+        rust_lib = sysroot.rust_std,  # `rust_lib` is deprecated and only exists for legacy support.
+        rust_std = sysroot.rust_std,
+        rust_std_paths = depset([file.dirname for file in sysroot.rust_std.to_list()]),
+        rustc = sysroot.rustc,
+        rustc_lib = sysroot.rustc_lib,
+        rustc_srcs = ctx.attr.rustc_srcs,
+        rustfmt = sysroot.rustfmt,
+        staticlib_ext = ctx.attr.staticlib_ext,
+        stdlib_linkflags = stdlib_linkflags_cc_info,
+        sysroot = sysroot_path,
+        sysroot_short_path = sysroot_short_path,
+        target_arch = ctx.attr.target_triple.split("-")[0],
+        target_flag_value = ctx.file.target_json.path if ctx.file.target_json else ctx.attr.target_triple,
+        target_json = ctx.file.target_json,
+        target_triple = ctx.attr.target_triple,
+
+        # Experimental and incompatible flags
+        _rename_first_party_crates = rename_first_party_crates,
+        _third_party_dir = third_party_dir,
+    )
+    return [toolchain]
+
+rust_toolchain = rule(
+    implementation = _rust_toolchain_impl,
+    fragments = ["cpp"],
+    attrs = {
+        "allocator_library": attr.label(
+            doc = "Target that provides allocator functions when rust_library targets are embedded in a cc_binary.",
+        ),
+        "binary_ext": attr.string(
+            doc = "The extension for binaries created from rustc.",
+            mandatory = True,
+        ),
+        "cargo": attr.label(
+            doc = "The location of the `cargo` binary. Can be a direct source or a filegroup containing one item.",
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+        "clippy_driver": attr.label(
+            doc = "The location of the `clippy-driver` binary. Can be a direct source or a filegroup containing one item.",
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+        "debug_info": attr.string_dict(
+            doc = "Rustc debug info levels per opt level",
+            default = {
+                "dbg": "2",
+                "fastbuild": "0",
+                "opt": "0",
+            },
+        ),
+        "default_edition": attr.string(
+            doc = "The edition to use for rust_* rules that don't specify an edition.",
+            default = rust_common.default_edition,
+        ),
+        "dylib_ext": attr.string(
+            doc = "The extension for dynamic libraries created from rustc.",
+            mandatory = True,
+        ),
+        "exec_triple": attr.string(
+            doc = (
+                "The platform triple for the toolchains execution environment. " +
+                "For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations"
+            ),
+            mandatory = True,
+        ),
+        "llvm_tools": attr.label(
+            doc = "LLVM tools that are shipped with the Rust toolchain.",
+            allow_files = True,
+        ),
+        "opt_level": attr.string_dict(
+            doc = "Rustc optimization levels.",
+            default = {
+                "dbg": "0",
+                "fastbuild": "0",
+                "opt": "3",
+            },
+        ),
+        "os": attr.string(
+            doc = "The operating system for the current toolchain",
+            mandatory = True,
+        ),
+        "rust_doc": attr.label(
+            doc = "The location of the `rustdoc` binary. Can be a direct source or a filegroup containing one item.",
+            allow_single_file = True,
+            cfg = "exec",
+            mandatory = True,
+        ),
+        "rust_lib": attr.label(
+            doc = "**Deprecated**: Use `rust_std`",
+        ),
+        "rust_std": attr.label(
+            doc = "The Rust standard library.",
+        ),
+        "rustc": attr.label(
+            doc = "The location of the `rustc` binary. Can be a direct source or a filegroup containing one item.",
+            allow_single_file = True,
+            cfg = "exec",
+            mandatory = True,
+        ),
+        "rustc_lib": attr.label(
+            doc = "The libraries used by rustc during compilation.",
+            cfg = "exec",
+        ),
+        "rustc_srcs": attr.label(
+            doc = "The source code of rustc.",
+        ),
+        "rustfmt": attr.label(
+            doc = "The location of the `rustfmt` binary. Can be a direct source or a filegroup containing one item.",
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+        "staticlib_ext": attr.string(
+            doc = "The extension for static libraries created from rustc.",
+            mandatory = True,
+        ),
+        "stdlib_linkflags": attr.string_list(
+            doc = (
+                "Additional linker flags to use when Rust standard library is linked by a C++ linker " +
+                "(rustc will deal with these automatically). Subject to location expansion with respect " +
+                "to the srcs of the `rust_std` attribute."
+            ),
+            mandatory = True,
+        ),
+        "target_json": attr.label(
+            doc = ("Override the target_triple with a custom target specification. " +
+                   "For more details see: https://doc.rust-lang.org/rustc/targets/custom.html"),
+            allow_single_file = True,
+        ),
+        "target_triple": attr.string(
+            doc = (
+                "The platform triple for the toolchains target environment. " +
+                "For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations"
+            ),
+        ),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_rename_first_party_crates": attr.label(
+            default = "@rules_rust//rust/settings:rename_first_party_crates",
+        ),
+        "_third_party_dir": attr.label(
+            default = "@rules_rust//rust/settings:third_party_dir",
+        ),
+    },
+    toolchains = [
+        "@bazel_tools//tools/cpp:toolchain_type",
+    ],
+    incompatible_use_toolchain_transition = True,
+    doc = """Declares a Rust toolchain for use.
+
+This is for declaring a custom toolchain, eg. for configuring a particular version of rust or supporting a new platform.
+
+Example:
+
+Suppose the core rust team has ported the compiler to a new target CPU, called `cpuX`. This \
+support can be used in Bazel by defining a new toolchain definition and declaration:
+
+```python
+load('@rules_rust//rust:toolchain.bzl', 'rust_toolchain')
+
+rust_toolchain(
+    name = "rust_cpuX_impl",
+    rustc = "@rust_cpuX//:rustc",
+    rustc_lib = "@rust_cpuX//:rustc_lib",
+    rust_std = "@rust_cpuX//:rust_std",
+    rust_doc = "@rust_cpuX//:rustdoc",
+    binary_ext = "",
+    staticlib_ext = ".a",
+    dylib_ext = ".so",
+    stdlib_linkflags = ["-lpthread", "-ldl"],
+    os = "linux",
+)
+
+toolchain(
+    name = "rust_cpuX",
+    exec_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:cpuX",
+    ],
+    toolchain = ":rust_cpuX_impl",
+)
+```
+
+Then, either add the label of the toolchain rule to `register_toolchains` in the WORKSPACE, or pass \
+it to the `"--extra_toolchains"` flag for Bazel, and it will be used.
+
+See @rules_rust//rust:repositories.bzl for examples of defining the @rust_cpuX repository \
+with the actual binaries and libraries.
+""",
+)
diff --git a/third_party/rules_rust/rust/toolchain/BUILD.bazel b/third_party/rules_rust/rust/toolchain/BUILD.bazel
new file mode 100644
index 0000000..daccd08
--- /dev/null
+++ b/third_party/rules_rust/rust/toolchain/BUILD.bazel
@@ -0,0 +1,43 @@
+load("//rust/private:toolchain_utils.bzl", "toolchain_files")
+
+package(default_visibility = ["//visibility:public"])
+
+toolchain_files(
+    name = "current_exec_cargo_files",
+    tool = "cargo",
+)
+
+toolchain_files(
+    name = "current_exec_clippy_files",
+    tool = "clippy",
+)
+
+toolchain_files(
+    name = "current_exec_rustc_files",
+    tool = "rustc",
+)
+
+toolchain_files(
+    name = "current_exec_rustdoc_files",
+    tool = "rustdoc",
+)
+
+toolchain_files(
+    name = "current_exec_rustfmt_files",
+    tool = "rustfmt",
+)
+
+toolchain_files(
+    name = "current_exec_rustc_lib_files",
+    tool = "rustc_lib",
+)
+
+toolchain_files(
+    name = "current_exec_rustc_srcs_files",
+    tool = "rustc_srcs",
+)
+
+toolchain_files(
+    name = "current_exec_rust_stdlib_files",
+    tool = "rust_stdlib",
+)
diff --git a/third_party/rules_rust/test/BUILD.bazel b/third_party/rules_rust/test/BUILD.bazel
new file mode 100644
index 0000000..a217437
--- /dev/null
+++ b/third_party/rules_rust/test/BUILD.bazel
@@ -0,0 +1,19 @@
+load(
+    "@bazel_tools//tools/build_rules:test_rules.bzl",
+    "rule_test",
+)
+
+rule_test(
+    name = "hello_lib_rule_test",
+    generates = ["libhello_lib-683707109.rlib"],
+    rule = "//test/rust:hello_lib",
+)
+
+rule_test(
+    name = "hello_world_rule_test",
+    generates = select({
+        "//rust/platform:windows": ["hello_world.exe"],
+        "//conditions:default": ["hello_world"],
+    }),
+    rule = "//test/rust:hello_world",
+)
diff --git a/third_party/rules_rust/test/build_env/BUILD.bazel b/third_party/rules_rust/test/build_env/BUILD.bazel
new file mode 100644
index 0000000..4fd7df3
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/BUILD.bazel
@@ -0,0 +1,40 @@
+load(
+    "//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+load("//rust:defs.bzl", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_test(
+    name = "conflicting_deps_test",
+    srcs = ["tests/manifest_dir.rs"],
+    data = ["src/manifest_dir_file.txt"],
+)
+
+rust_test(
+    name = "arbitrary_env_test",
+    srcs = ["tests/arbitrary_env.rs"],
+    rustc_env = {
+        "USER_DEFINED_KEY": "USER_DEFINED_VALUE",
+    },
+)
+
+rust_test(
+    # Intentionally uses a mix of -s and _s because those normalisations are part of what is being tested.
+    name = "cargo_env-vars_test",
+    srcs = ["tests/cargo.rs"],
+    deps = [":cargo_build_script_env-vars_build_script"],
+)
+
+rust_test(
+    name = "cargo-env-vars-custom-crate-name-test",
+    srcs = ["tests/custom_crate_name.rs"],
+    crate_name = "custom_crate_name",
+    deps = [":cargo_build_script_env-vars_build_script"],
+)
+
+cargo_build_script(
+    name = "cargo_build_script_env-vars_build_script",
+    srcs = ["src/build.rs"],
+)
diff --git a/third_party/rules_rust/test/build_env/src/build.rs b/third_party/rules_rust/test/build_env/src/build.rs
new file mode 100644
index 0000000..654572a
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/src/build.rs
@@ -0,0 +1,11 @@
+fn main() {
+    println!(
+        "cargo:rustc-env=CARGO_PKG_NAME_FROM_BUILD_SCRIPT={}",
+        env!("CARGO_PKG_NAME")
+    );
+    println!(
+        "cargo:rustc-env=CARGO_CRATE_NAME_FROM_BUILD_SCRIPT={}",
+        env!("CARGO_CRATE_NAME")
+    );
+    println!("cargo:rustc-env=HAS_TRAILING_SLASH=foo\\");
+}
diff --git a/third_party/rules_rust/test/build_env/src/manifest_dir_file.txt b/third_party/rules_rust/test/build_env/src/manifest_dir_file.txt
new file mode 100644
index 0000000..f3a8cad
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/src/manifest_dir_file.txt
@@ -0,0 +1 @@
+This file tests that CARGO_MANIFEST_DIR is set for the build environment
diff --git a/third_party/rules_rust/test/build_env/tests/arbitrary_env.rs b/third_party/rules_rust/test/build_env/tests/arbitrary_env.rs
new file mode 100644
index 0000000..1b9ab23
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/tests/arbitrary_env.rs
@@ -0,0 +1,6 @@
+#[test]
+pub fn test_arbitrary_env() {
+    let actual = env!("USER_DEFINED_KEY");
+    let expected = "USER_DEFINED_VALUE".to_owned();
+    assert_eq!(actual, expected);
+}
diff --git a/third_party/rules_rust/test/build_env/tests/cargo.rs b/third_party/rules_rust/test/build_env/tests/cargo.rs
new file mode 100644
index 0000000..2c9d244
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/tests/cargo.rs
@@ -0,0 +1,14 @@
+#[test]
+fn cargo_env_vars() {
+    assert_eq!(env!("CARGO_PKG_NAME"), "cargo_env-vars_test");
+    assert_eq!(env!("CARGO_CRATE_NAME"), "cargo_env_vars_test");
+    assert_eq!(
+        env!("CARGO_PKG_NAME_FROM_BUILD_SCRIPT"),
+        "cargo_build_script_env-vars"
+    );
+    assert_eq!(
+        env!("CARGO_CRATE_NAME_FROM_BUILD_SCRIPT"),
+        "cargo_build_script_env_vars"
+    );
+    assert_eq!(env!("HAS_TRAILING_SLASH"), "foo\\");
+}
diff --git a/third_party/rules_rust/test/build_env/tests/custom_crate_name.rs b/third_party/rules_rust/test/build_env/tests/custom_crate_name.rs
new file mode 100644
index 0000000..e80bd89
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/tests/custom_crate_name.rs
@@ -0,0 +1,8 @@
+#[test]
+fn cargo_env_vars() {
+    assert_eq!(
+        env!("CARGO_PKG_NAME"),
+        "cargo-env-vars-custom-crate-name-test"
+    );
+    assert_eq!(env!("CARGO_CRATE_NAME"), "custom_crate_name");
+}
diff --git a/third_party/rules_rust/test/build_env/tests/manifest_dir.rs b/third_party/rules_rust/test/build_env/tests/manifest_dir.rs
new file mode 100644
index 0000000..e574801
--- /dev/null
+++ b/third_party/rules_rust/test/build_env/tests/manifest_dir.rs
@@ -0,0 +1,10 @@
+#[test]
+pub fn test_manifest_dir() {
+    let actual = include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/src/manifest_dir_file.txt"
+    ))
+    .trim_end();
+    let expected = "This file tests that CARGO_MANIFEST_DIR is set for the build environment";
+    assert_eq!(actual, expected);
+}
diff --git a/third_party/rules_rust/test/cargo_build_script/BUILD.bazel b/third_party/rules_rust/test/cargo_build_script/BUILD.bazel
new file mode 100644
index 0000000..34744cb
--- /dev/null
+++ b/third_party/rules_rust/test/cargo_build_script/BUILD.bazel
@@ -0,0 +1,27 @@
+"""Tests for the cargo_build_script rule"""
+
+load("//cargo:cargo_build_script.bzl", "cargo_build_script")
+load("//rust:defs.bzl", "rust_test")
+
+# Test that tools are built in the exec configuration.
+cargo_build_script(
+    name = "tools_exec_build_rs",
+    srcs = ["build.rs"],
+    build_script_env = {"TOOL": "$(execpath :tool)"},
+    # Add a flag to test that they're exposed to the build script
+    rustc_flags = ["--verbose"],
+    tools = [":tool"],
+)
+
+genrule(
+    name = "tool",
+    srcs = [],
+    outs = ["tool-file"],
+    cmd = "touch $@",
+)
+
+rust_test(
+    name = "tools_exec",
+    srcs = ["tools_exec.rs"],
+    deps = [":tools_exec_build_rs"],
+)
diff --git a/third_party/rules_rust/test/cargo_build_script/build.rs b/third_party/rules_rust/test/cargo_build_script/build.rs
new file mode 100644
index 0000000..12d1b53
--- /dev/null
+++ b/third_party/rules_rust/test/cargo_build_script/build.rs
@@ -0,0 +1,50 @@
+//! A Cargo build script binary used in unit tests for the Bazel `cargo_build_script` rule
+
+/// `cargo_build_script` should always set `CARGO_ENCODED_RUSTFLAGS`
+fn test_encoded_rustflags() {
+    let encoded_rustflags = std::env::var("CARGO_ENCODED_RUSTFLAGS").unwrap();
+
+    let flags: Vec<String> = encoded_rustflags
+        .split('\x1f')
+        .map(str::to_string)
+        .collect();
+    assert_eq!(flags.len(), 2);
+
+    assert!(flags[0].starts_with("--sysroot"));
+
+    // Ensure the `pwd` template has been resolved
+    assert!(!flags[0].contains("${pwd}"));
+
+    assert_eq!(flags[1], "--verbose");
+}
+
+fn main() {
+    // Perform some unit testing
+    test_encoded_rustflags();
+
+    // Pass the TOOL_PATH along to the rust_test so we can assert on it.
+    println!(
+        "cargo:rustc-env=TOOL_PATH={}",
+        std::env::var("TOOL").unwrap()
+    );
+
+    // Assert that the CC and CXX env vars existed and were executable.
+    // We don't assert what happens when they're executed (in particular, we don't check for a
+    // non-zero exit code), but this asserts that it's an existing file which is executable.
+    //
+    // Unfortunately we need to shlex the path, because we add a `--sysroot=...` arg to the env var.
+    for env_var in &["CC", "CXX"] {
+        let v = std::env::var(env_var)
+            .unwrap_or_else(|err| panic!("Error getting {}: {}", env_var, err));
+        let (path, args) = if let Some(index) = v.find("--sysroot") {
+            let (path, args) = v.split_at(index);
+            (path, Some(args))
+        } else {
+            (v.as_str(), None)
+        };
+        std::process::Command::new(path)
+            .args(args.into_iter())
+            .status()
+            .unwrap();
+    }
+}
diff --git a/third_party/rules_rust/test/cargo_build_script/tools_exec.rs b/third_party/rules_rust/test/cargo_build_script/tools_exec.rs
new file mode 100644
index 0000000..6b06920
--- /dev/null
+++ b/third_party/rules_rust/test/cargo_build_script/tools_exec.rs
@@ -0,0 +1,9 @@
+#[test]
+pub fn test_tool_exec() {
+    let tool_path = env!("TOOL_PATH");
+    assert!(
+        tool_path.contains("-exec-"),
+        "tool_path did not contain '-exec-': {}",
+        tool_path
+    );
+}
diff --git a/third_party/rules_rust/test/chained_direct_deps/BUILD.bazel b/third_party/rules_rust/test/chained_direct_deps/BUILD.bazel
new file mode 100644
index 0000000..8460d22
--- /dev/null
+++ b/third_party/rules_rust/test/chained_direct_deps/BUILD.bazel
@@ -0,0 +1,41 @@
+load("//rust:defs.bzl", "rust_doc_test", "rust_library", "rust_test")
+
+rust_library(
+    name = "mod1",
+    srcs = ["mod1.rs"],
+)
+
+rust_library(
+    name = "mod2",
+    srcs = ["mod2.rs"],
+    deps = [":mod1"],
+)
+
+rust_library(
+    name = "mod3",
+    srcs = ["mod3.rs"],
+    deps = [
+        ":mod1",
+        ":mod2",
+    ],
+)
+
+rust_test(
+    name = "mod1_test",
+    crate = ":mod1",
+)
+
+rust_test(
+    name = "mod2_test",
+    crate = ":mod2",
+)
+
+rust_test(
+    name = "mod3_test",
+    crate = ":mod3",
+)
+
+rust_doc_test(
+    name = "mod3_doc_test",
+    crate = ":mod3",
+)
diff --git a/third_party/rules_rust/test/chained_direct_deps/mod1.rs b/third_party/rules_rust/test/chained_direct_deps/mod1.rs
new file mode 100644
index 0000000..a66f490
--- /dev/null
+++ b/third_party/rules_rust/test/chained_direct_deps/mod1.rs
@@ -0,0 +1,11 @@
+pub fn world() -> String {
+    "world".to_owned()
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_world() {
+        assert_eq!(super::world(), "world");
+    }
+}
diff --git a/third_party/rules_rust/test/chained_direct_deps/mod2.rs b/third_party/rules_rust/test/chained_direct_deps/mod2.rs
new file mode 100644
index 0000000..cff993b
--- /dev/null
+++ b/third_party/rules_rust/test/chained_direct_deps/mod2.rs
@@ -0,0 +1,22 @@
+extern crate mod1;
+
+pub fn greeter(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+pub fn default_greeter() -> String {
+    greeter(&mod1::world())
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_greeter() {
+        assert_eq!(super::greeter("Bob"), "Hello, Bob!");
+    }
+
+    #[test]
+    fn test_default_greeter() {
+        assert_eq!(super::default_greeter(), "Hello, world!");
+    }
+}
diff --git a/third_party/rules_rust/test/chained_direct_deps/mod3.rs b/third_party/rules_rust/test/chained_direct_deps/mod3.rs
new file mode 100644
index 0000000..2f31e6d
--- /dev/null
+++ b/third_party/rules_rust/test/chained_direct_deps/mod3.rs
@@ -0,0 +1,38 @@
+// This crate depends on 2 crates with one of them depending on the other one.
+// If the crates are not set correctly in the dependency chain, this crate won't
+// compile. The order of the `extern crate` is important to trigger that bug.
+extern crate mod1;
+extern crate mod2;
+
+pub fn greet(name: &str) {
+    println!("{}", mod2::greeter(name))
+}
+
+pub fn greet_default() {
+    println!("{}", mod2::default_greeter())
+}
+
+/// This is a documentation.
+///
+/// # Examples
+///
+/// ```rust
+/// assert!(
+///   mod3::am_i_the_world("world") == true
+/// );
+/// assert!(
+///   mod3::am_i_the_world("myself") == false
+/// );
+/// ```
+pub fn am_i_the_world(me: &str) -> bool {
+    me == mod1::world()
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_am_i_the_world() {
+        assert!(super::am_i_the_world("world"));
+        assert!(!super::am_i_the_world("bob"));
+    }
+}
diff --git a/third_party/rules_rust/test/clippy/BUILD.bazel b/third_party/rules_rust/test/clippy/BUILD.bazel
new file mode 100644
index 0000000..bcd8159
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/BUILD.bazel
@@ -0,0 +1,90 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_clippy", "rust_library", "rust_test")
+
+package(default_visibility = ["//test:__subpackages__"])
+
+# Declaration of passing targets.
+
+rust_binary(
+    name = "ok_binary",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+)
+
+rust_library(
+    name = "ok_library",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+)
+
+rust_test(
+    name = "ok_test",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+)
+
+# Clippy analysis of passing targets.
+
+rust_clippy(
+    name = "ok_binary_clippy",
+    deps = [":ok_binary"],
+)
+
+rust_clippy(
+    name = "ok_library_clippy",
+    deps = [":ok_library"],
+)
+
+rust_clippy(
+    name = "ok_test_clippy",
+    testonly = True,
+    deps = [":ok_test"],
+)
+
+# Declaration of failing targets.
+
+rust_binary(
+    name = "bad_binary",
+    srcs = ["bad_src/main.rs"],
+    edition = "2018",
+    tags = ["noclippy"],
+)
+
+rust_library(
+    name = "bad_library",
+    srcs = ["bad_src/lib.rs"],
+    edition = "2018",
+    tags = ["noclippy"],
+)
+
+rust_test(
+    name = "bad_test",
+    srcs = ["bad_src/lib.rs"],
+    edition = "2018",
+    tags = ["noclippy"],
+)
+
+# Clippy analysis of failing targets.
+
+rust_clippy(
+    name = "bad_binary_clippy",
+    tags = ["manual"],
+    deps = [":bad_binary"],
+)
+
+rust_clippy(
+    name = "bad_library_clippy",
+    tags = ["manual"],
+    deps = [":bad_library"],
+)
+
+rust_clippy(
+    name = "bad_test_clippy",
+    testonly = True,
+    tags = ["manual"],
+    deps = [":bad_test"],
+)
+
+sh_binary(
+    name = "clippy_failure_test",
+    srcs = ["clippy_failure_test.sh"],
+)
diff --git a/third_party/rules_rust/test/clippy/README.md b/third_party/rules_rust/test/clippy/README.md
new file mode 100644
index 0000000..40db34f
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/README.md
@@ -0,0 +1,12 @@
+# Clippy Tests
+
+This directory tests integration of the Clippy static analyzer aspect.
+
+It is split into a couple different directories:
+
+* [src](src) contains a simple binary, library and test which should compile
+successfully when built normally, and pass without error when analyzed
+with clippy.
+* [bad\_src](bad_src) also contains a binary, library, and test which compile
+normally, but which intentionally contain "junk code" which will trigger
+Clippy lints.
diff --git a/third_party/rules_rust/test/clippy/bad_src/lib.rs b/third_party/rules_rust/test/clippy/bad_src/lib.rs
new file mode 100644
index 0000000..ec29e04
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/bad_src/lib.rs
@@ -0,0 +1,19 @@
+pub fn foobar() {
+    assert!(true);
+    loop {
+        println!("{}", "Hello World");
+        break;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_works() {
+        assert!(true);
+        loop {
+            println!("{}", "Hello World");
+            break;
+        }
+    }
+}
diff --git a/third_party/rules_rust/test/clippy/bad_src/main.rs b/third_party/rules_rust/test/clippy/bad_src/main.rs
new file mode 100644
index 0000000..cf9d4e6
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/bad_src/main.rs
@@ -0,0 +1,6 @@
+fn main() {
+    loop {
+        println!("{}", "Hello World");
+        break;
+    }
+}
diff --git a/third_party/rules_rust/test/clippy/clippy_failure_test.sh b/third_party/rules_rust/test/clippy/clippy_failure_test.sh
new file mode 100755
index 0000000..dee4b82
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/clippy_failure_test.sh
@@ -0,0 +1,102 @@
+#!/bin/bash
+
+# Runs Bazel build commands over clippy rules, where some are expected
+# to fail.
+#
+# Can be run from anywhere within the rules_rust workspace.
+
+set -euo pipefail
+
+if [[ -z "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then
+  echo "This script should be run under Bazel"
+  exit 1
+fi
+
+cd "${BUILD_WORKSPACE_DIRECTORY}"
+
+TEMP_DIR="$(mktemp -d -t ci-XXXXXXXXXX)"
+NEW_WORKSPACE="${TEMP_DIR}/rules_rust_test_clippy"
+
+# Executes a bazel build command and handles the return value, exiting
+# upon seeing an error.
+#
+# Takes two arguments:
+# ${1}: The expected return code.
+# ${2}: The target within "//test/clippy" to be tested.
+#
+# Any additional arguments are passed to `bazel build`.
+function check_build_result() {
+  local ret=0
+  echo -n "Testing ${2}... "
+  (bazel build ${@:3} //test/clippy:"${2}" &> /dev/null) || ret="$?" && true
+  if [[ "${ret}" -ne "${1}" ]]; then
+    echo "FAIL: Unexpected return code [saw: ${ret}, want: ${1}] building target //test/clippy:${2}"
+    echo "  Run \"bazel build //test/clippy:${2}\" to see the output"
+    exit 1
+  elif [[ $# -ge 3 ]] && [[ "${@:3}" == *"capture_clippy_output"* ]]; then
+    # Make sure that content was written to the output file
+    if [ "$(uname)" == "Darwin" ]; then
+      STATOPTS=(-f%z)
+    else
+      STATOPTS=(-c%s)
+    fi
+    if [[ $(stat ${STATOPTS[@]} "${NEW_WORKSPACE}/bazel-bin/test/clippy/${2%_clippy}.clippy.out") == 0 ]]; then
+      echo "FAIL: Output wasn't written to out file building target //test/clippy:${2}"
+      echo "  Output file: ${NEW_WORKSPACE}/bazel-bin/test/clippy/${2%_clippy}.clippy.out"
+      echo "  Run \"bazel build //test/clippy:${2}\" to see the output"
+      exit 1
+    else
+      echo "OK"
+    fi
+  else
+    echo "OK"
+  fi
+}
+
+function test_all() {
+  local -r BUILD_OK=0
+  local -r BUILD_FAILED=1
+  local -r CAPTURE_OUTPUT="--@rules_rust//:capture_clippy_output=True --@rules_rust//:error_format=json"
+  local -r BAD_CLIPPY_TOML="--@rules_rust//:clippy.toml=//too_many_args:clippy.toml"
+
+  mkdir -p "${NEW_WORKSPACE}/test/clippy" && \
+  cp -r test/clippy/* "${NEW_WORKSPACE}/test/clippy/" && \
+  cat << EOF > "${NEW_WORKSPACE}/WORKSPACE.bazel"
+workspace(name = "rules_rust_test_clippy")
+local_repository(
+    name = "rules_rust",
+    path = "${BUILD_WORKSPACE_DIRECTORY}",
+)
+load("@rules_rust//rust:repositories.bzl", "rust_repositories")
+rust_repositories()
+EOF
+
+  # Drop the 'noclippy' tags
+  if [ "$(uname)" == "Darwin" ]; then
+    SEDOPTS=(-i '' -e)
+  else
+    SEDOPTS=(-i)
+  fi
+  sed ${SEDOPTS[@]} 's/"noclippy"//' "${NEW_WORKSPACE}/test/clippy/BUILD.bazel"
+
+  pushd "${NEW_WORKSPACE}"
+
+  check_build_result $BUILD_OK ok_binary_clippy
+  check_build_result $BUILD_OK ok_library_clippy
+  check_build_result $BUILD_OK ok_test_clippy
+  check_build_result $BUILD_FAILED bad_binary_clippy
+  check_build_result $BUILD_FAILED bad_library_clippy
+  check_build_result $BUILD_FAILED bad_test_clippy
+
+  # When capturing output, clippy errors are treated as warnings and the build
+  # should succeed.
+  check_build_result $BUILD_OK bad_binary_clippy $CAPTURE_OUTPUT
+  check_build_result $BUILD_OK bad_library_clippy $CAPTURE_OUTPUT
+  check_build_result $BUILD_OK bad_test_clippy $CAPTURE_OUTPUT
+
+  # Test that we can make the ok_library_clippy fail when using an extra config file.
+  # Proves that the config file is used and overrides default settings.
+  check_build_result $BUILD_FAILED ok_library_clippy $BAD_CLIPPY_TOML
+}
+
+test_all
diff --git a/third_party/rules_rust/test/clippy/src/lib.rs b/third_party/rules_rust/test/clippy/src/lib.rs
new file mode 100644
index 0000000..c55a340
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/src/lib.rs
@@ -0,0 +1,15 @@
+pub fn greeting() -> String {
+    "Hello World".to_owned()
+}
+
+// too_many_args/clippy.toml will require no more than 2 args.
+pub fn with_args(_: u32, _: u32, _: u32) {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(greeting(), "Hello World".to_owned());
+    }
+}
diff --git a/third_party/rules_rust/test/clippy/src/main.rs b/third_party/rules_rust/test/clippy/src/main.rs
new file mode 100644
index 0000000..5bf256e
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello world");
+}
diff --git a/third_party/rules_rust/test/clippy/too_many_args/BUILD.bazel b/third_party/rules_rust/test/clippy/too_many_args/BUILD.bazel
new file mode 100644
index 0000000..09e246f
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/too_many_args/BUILD.bazel
@@ -0,0 +1 @@
+exports_files(["clippy.toml"])
diff --git a/third_party/rules_rust/test/clippy/too_many_args/clippy.toml b/third_party/rules_rust/test/clippy/too_many_args/clippy.toml
new file mode 100644
index 0000000..0d5329b
--- /dev/null
+++ b/third_party/rules_rust/test/clippy/too_many_args/clippy.toml
@@ -0,0 +1 @@
+too-many-arguments-threshold = 2
diff --git a/third_party/rules_rust/test/conflicting_deps/BUILD.bazel b/third_party/rules_rust/test/conflicting_deps/BUILD.bazel
new file mode 100644
index 0000000..852aec5
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/BUILD.bazel
@@ -0,0 +1,17 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "conflicting_deps",
+    srcs = ["lib.rs"],
+    edition = "2015",
+    deps = [
+        "//test/conflicting_deps/first_crate:example_name_conflict",
+    ],
+)
+
+rust_test(
+    name = "conflicting_deps_test",
+    crate = ":conflicting_deps",
+)
diff --git a/third_party/rules_rust/test/conflicting_deps/first_crate/BUILD.bazel b/third_party/rules_rust/test/conflicting_deps/first_crate/BUILD.bazel
new file mode 100644
index 0000000..f759e19
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/first_crate/BUILD.bazel
@@ -0,0 +1,12 @@
+load("//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "example_name_conflict",
+    srcs = ["lib.rs"],
+    edition = "2015",
+    deps = [
+        "//test/conflicting_deps/second_crate:example_name_conflict",
+    ],
+)
diff --git a/third_party/rules_rust/test/conflicting_deps/first_crate/lib.rs b/third_party/rules_rust/test/conflicting_deps/first_crate/lib.rs
new file mode 100644
index 0000000..b72986e
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/first_crate/lib.rs
@@ -0,0 +1,10 @@
+// This crate's name conflicts with its dependency but this should work OK.
+
+extern crate example_name_conflict;
+
+pub fn example_conflicting_symbol() -> String {
+    format!(
+        "[from first_crate] -> {}",
+        example_name_conflict::example_conflicting_symbol()
+    )
+}
diff --git a/third_party/rules_rust/test/conflicting_deps/lib.rs b/third_party/rules_rust/test/conflicting_deps/lib.rs
new file mode 100644
index 0000000..a3e6307
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/lib.rs
@@ -0,0 +1,22 @@
+extern crate example_name_conflict;
+
+// This crate depends on a pair of dependencies (transitively) that have the same name. This should
+// work OK.
+
+pub fn example_conflicting_symbol() -> String {
+    format!(
+        "[from main lib] -> {}",
+        example_name_conflict::example_conflicting_symbol()
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn symbols_all_resolve_correctly() {
+        assert_eq!(
+            ::example_conflicting_symbol(),
+            "[from main lib] -> [from first_crate] -> [from second_crate]".to_owned()
+        );
+    }
+}
diff --git a/third_party/rules_rust/test/conflicting_deps/second_crate/BUILD.bazel b/third_party/rules_rust/test/conflicting_deps/second_crate/BUILD.bazel
new file mode 100644
index 0000000..d7d510f
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/second_crate/BUILD.bazel
@@ -0,0 +1,10 @@
+load("//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "example_name_conflict",
+    srcs = ["lib.rs"],
+    edition = "2015",
+    deps = [],
+)
diff --git a/third_party/rules_rust/test/conflicting_deps/second_crate/lib.rs b/third_party/rules_rust/test/conflicting_deps/second_crate/lib.rs
new file mode 100644
index 0000000..2aa768d
--- /dev/null
+++ b/third_party/rules_rust/test/conflicting_deps/second_crate/lib.rs
@@ -0,0 +1,5 @@
+// This crate's name conflicts with its dependent but this should work OK.
+
+pub fn example_conflicting_symbol() -> String {
+    "[from second_crate]".to_owned()
+}
diff --git a/third_party/rules_rust/test/current_toolchain_files/BUILD.bazel b/third_party/rules_rust/test/current_toolchain_files/BUILD.bazel
new file mode 100644
index 0000000..e617417
--- /dev/null
+++ b/third_party/rules_rust/test/current_toolchain_files/BUILD.bazel
@@ -0,0 +1,43 @@
+# Executable targets will output a pattern similar to the following
+# cargo 1.53.0 (4369396ce 2021-04-27)
+# Also Note, rustc_srcs is too big for this test
+_FILES = {
+    "cargo": ("--executable", r"^cargo [0-9\.]\+ ([0-9a-z]\+ [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\})"),
+    "clippy": ("--executable", r"^clippy [0-9\.]\+ ([0-9a-z]\+ [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\})"),
+    "rust_stdlib": ("--files", r"\.rlib"),
+    "rustc": ("--executable", r"^rustc [0-9\.]\+ ([0-9a-z]\+ [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\})"),
+    "rustc_lib": ("--files", r"rustc_driver"),
+    "rustdoc": ("--executable", r"^rustdoc [0-9\.]\+ ([0-9a-z]\+ [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\})"),
+    "rustfmt": ("--executable", r"^rustfmt [0-9\.]\+\-stable ([0-9a-z]\+ [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\})"),
+}
+
+# Generate a list manifest for all files in the filegroup
+[
+    genrule(
+        name = "{}_manifest_genrule".format(files),
+        srcs = ["//rust/toolchain:current_exec_{}_files".format(files)],
+        outs = ["{}_manifest".format(files)],
+        cmd = "for file in $(rootpaths //rust/toolchain:current_exec_{}_files); do echo $$file >> $@; done".format(files),
+    )
+    for files in _FILES
+    if "--files" in _FILES[files]
+]
+
+# Test that all toolchain tools are executable targets
+[
+    sh_test(
+        name = tool + "_test",
+        srcs = ["current_exec_files_test.sh"],
+        args = [
+            "$(rootpath //rust/toolchain:current_exec_{}_files)".format(tool) if "--executable" == arg else "$(rootpath {}_manifest)".format(tool),
+            arg,
+            "'{}'".format(pattern),
+        ],
+        data = [
+            "//rust/toolchain:current_exec_{}_files".format(tool),
+        ] + (
+            ["{}_manifest".format(tool)] if "--files" == arg else []
+        ),
+    )
+    for tool, (arg, pattern) in _FILES.items()
+]
diff --git a/third_party/rules_rust/test/current_toolchain_files/current_exec_files_test.sh b/third_party/rules_rust/test/current_toolchain_files/current_exec_files_test.sh
new file mode 100755
index 0000000..5e89661
--- /dev/null
+++ b/third_party/rules_rust/test/current_toolchain_files/current_exec_files_test.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -euo pipefail
+
+TARGET="$1"
+OPTION="$2"
+
+# To parse this argument on windows it must be wrapped in quotes but
+# these quotes should not be passed to grep. Remove them here.
+PATTERN="$(echo -n "$3" | sed "s/'//g")"
+
+if [[ "${OPTION}" == "--executable" ]]; then
+    # Clippy requires this environment variable is set
+    export SYSROOT=""
+
+    "${TARGET}" --version
+    "${TARGET}" --version | grep "${PATTERN}"
+    exit 0
+fi
+
+if [[ "${OPTION}" == "--files" ]]; then
+    cat "${TARGET}"
+    grep "${PATTERN}" "${TARGET}"
+    exit 0
+fi
+
+echo "Unexpected option: ${OPTION}"
+exit 1
diff --git a/third_party/rules_rust/test/deps.bzl b/third_party/rules_rust/test/deps.bzl
new file mode 100644
index 0000000..58c09bc
--- /dev/null
+++ b/third_party/rules_rust/test/deps.bzl
@@ -0,0 +1,33 @@
+"""A module defining dependencies of the `rules_rust` tests"""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//test/load_arbitrary_tool:load_arbitrary_tool_test.bzl", "load_arbitrary_tool_test")
+
+_LIBC_BUILD_FILE_CONTENT = """\
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "libc",
+    srcs = glob(["src/**/*.rs"]),
+    edition = "2015",
+    visibility = ["//visibility:public"],
+)
+"""
+
+def rules_rust_test_deps():
+    """Load dependencies for rules_rust tests"""
+
+    load_arbitrary_tool_test()
+
+    maybe(
+        http_archive,
+        name = "libc",
+        build_file_content = _LIBC_BUILD_FILE_CONTENT,
+        sha256 = "1ac4c2ac6ed5a8fb9020c166bc63316205f1dc78d4b964ad31f4f21eb73f0c6d",
+        strip_prefix = "libc-0.2.20",
+        urls = [
+            "https://mirror.bazel.build/github.com/rust-lang/libc/archive/0.2.20.zip",
+            "https://github.com/rust-lang/libc/archive/0.2.20.zip",
+        ],
+    )
diff --git a/third_party/rules_rust/test/extra_exec_rustc_flags/BUILD.bazel b/third_party/rules_rust/test/extra_exec_rustc_flags/BUILD.bazel
new file mode 100644
index 0000000..a1b401e
--- /dev/null
+++ b/third_party/rules_rust/test/extra_exec_rustc_flags/BUILD.bazel
@@ -0,0 +1,54 @@
+load("@bazel_skylib//rules:build_test.bzl", "build_test")
+load("@rules_rust//rust:defs.bzl", "rust_library")
+load("defs.bzl", "with_exec_cfg", "with_extra_exec_rustc_flags_cfg")
+
+package(default_visibility = ["//test:__subpackages__"])
+
+# Checks that extra_exec_rustc_flags are passed in exec configuration.
+# lib.rs is a sample source file that requires a `--cfg=bazel_exec` flag to build.
+# These targets set up transitions so that building :lib triggers building
+# lib.rs in exec configuration with //:extra_exec_rustc_flags=[--cfg=bazel_exec].
+# The intermediate targets are tagged "manual" as they are not meant to be built
+# on their own.
+
+rust_library(
+    name = "lib_do_not_build_directly",
+    srcs = ["lib.rs"],
+    tags = ["manual"],
+)
+
+with_extra_exec_rustc_flags_cfg(
+    name = "lib_with_exec_flags_do_not_build_directly",
+    srcs = ["lib_do_not_build_directly"],
+    extra_exec_rustc_flags = ["--cfg=bazel_exec"],
+    tags = ["manual"],
+)
+
+with_exec_cfg(
+    name = "lib",
+    srcs = ["lib_with_exec_flags_do_not_build_directly"],
+)
+
+# Checks that extra_exec_rustc_flags are not passed in non-exec configurations.
+# lib_no_exec.rs is a sample source file that fails to build if
+# `--cfg=bazel_exec` is present. The targets below are built in non-exec configurations,
+# so they should build just fine with //:extra_exec_rustc_flags=[--cfg=bazel_exec].
+rust_library(
+    name = "lib_no_exec",
+    srcs = ["lib_no_exec.rs"],
+)
+
+with_extra_exec_rustc_flags_cfg(
+    name = "lib_no_exec_with_extra_build_flags",
+    srcs = ["lib_no_exec"],
+    extra_exec_rustc_flags = ["--cfg=bazel_exec"],
+)
+
+build_test(
+    name = "lib_build",
+    targets = [
+        ":lib",
+        ":lib_no_exec",
+        ":lib_no_exec_with_extra_build_flags",
+    ],
+)
diff --git a/third_party/rules_rust/test/extra_exec_rustc_flags/defs.bzl b/third_party/rules_rust/test/extra_exec_rustc_flags/defs.bzl
new file mode 100644
index 0000000..790cdc5
--- /dev/null
+++ b/third_party/rules_rust/test/extra_exec_rustc_flags/defs.bzl
@@ -0,0 +1,44 @@
+"""Test transitions to test extra_exec_rustc_flags."""
+
+def _extra_exec_rustc_flags_transition_impl(_settings, attr):
+    return {
+        "//:extra_exec_rustc_flags": attr.extra_exec_rustc_flags,
+    }
+
+_extra_exec_rustc_flags_transition = transition(
+    implementation = _extra_exec_rustc_flags_transition_impl,
+    inputs = [],
+    outputs = ["//:extra_exec_rustc_flags"],
+)
+
+def _with_extra_exec_rustc_flags_cfg_impl(ctx):
+    return [DefaultInfo(files = depset(ctx.files.srcs))]
+
+with_extra_exec_rustc_flags_cfg = rule(
+    implementation = _with_extra_exec_rustc_flags_cfg_impl,
+    attrs = {
+        "extra_exec_rustc_flags": attr.string_list(
+            mandatory = True,
+        ),
+        "srcs": attr.label_list(
+            allow_files = True,
+            cfg = _extra_exec_rustc_flags_transition,
+        ),
+        "_allowlist_function_transition": attr.label(
+            default = Label("//tools/allowlists/function_transition_allowlist"),
+        ),
+    },
+)
+
+def _with_exec_cfg_impl(ctx):
+    return [DefaultInfo(files = depset(ctx.files.srcs))]
+
+with_exec_cfg = rule(
+    implementation = _with_exec_cfg_impl,
+    attrs = {
+        "srcs": attr.label_list(
+            allow_files = True,
+            cfg = "exec",
+        ),
+    },
+)
diff --git a/third_party/rules_rust/test/extra_exec_rustc_flags/lib.rs b/third_party/rules_rust/test/extra_exec_rustc_flags/lib.rs
new file mode 100644
index 0000000..7857ffa
--- /dev/null
+++ b/third_party/rules_rust/test/extra_exec_rustc_flags/lib.rs
@@ -0,0 +1,7 @@
+// Sample source that fails to compile unless `--cfg=bazel_exec` is passed to rustc.
+#[cfg(bazel_exec)]
+fn exec() {}
+
+pub fn f() {
+    exec();
+}
diff --git a/third_party/rules_rust/test/extra_exec_rustc_flags/lib_no_exec.rs b/third_party/rules_rust/test/extra_exec_rustc_flags/lib_no_exec.rs
new file mode 100644
index 0000000..4046301
--- /dev/null
+++ b/third_party/rules_rust/test/extra_exec_rustc_flags/lib_no_exec.rs
@@ -0,0 +1,7 @@
+// Sample source that fails to compile if `--cfg=bazel_exec` is passed to rustc.
+#[cfg(not(bazel_exec))]
+fn exec() {}
+
+pub fn f() {
+    exec();
+}
diff --git a/third_party/rules_rust/test/inline_test_with_deps/BUILD.bazel b/third_party/rules_rust/test/inline_test_with_deps/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/BUILD.bazel
diff --git a/third_party/rules_rust/test/inline_test_with_deps/dep/BUILD.bazel b/third_party/rules_rust/test/inline_test_with_deps/dep/BUILD.bazel
new file mode 100644
index 0000000..3435e68
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/dep/BUILD.bazel
@@ -0,0 +1,8 @@
+load("//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "dep",
+    srcs = ["src/lib.rs"],
+)
diff --git a/third_party/rules_rust/test/inline_test_with_deps/dep/src/lib.rs b/third_party/rules_rust/test/inline_test_with_deps/dep/src/lib.rs
new file mode 100644
index 0000000..1c74669
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/dep/src/lib.rs
@@ -0,0 +1,4 @@
+/// This exists purely to give us a dep to compile against
+pub fn example_test_dep_fn() -> u32 {
+    1
+}
diff --git a/third_party/rules_rust/test/inline_test_with_deps/test/BUILD.bazel b/third_party/rules_rust/test/inline_test_with_deps/test/BUILD.bazel
new file mode 100644
index 0000000..372199c
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/test/BUILD.bazel
@@ -0,0 +1,15 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "inline",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+)
+
+rust_test(
+    name = "inline_test",
+    crate = ":inline",
+    deps = ["//test/inline_test_with_deps/dep"],
+)
diff --git a/third_party/rules_rust/test/inline_test_with_deps/test/src/lib.rs b/third_party/rules_rust/test/inline_test_with_deps/test/src/lib.rs
new file mode 100644
index 0000000..d6df950
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/test/src/lib.rs
@@ -0,0 +1,15 @@
+#[allow(dead_code)]
+fn multiply(val: u32) -> u32 {
+    val * 100
+}
+
+#[cfg(test)]
+mod tests {
+    use super::multiply;
+    use dep::example_test_dep_fn;
+
+    #[test]
+    fn test() {
+        assert_eq!(100, multiply(example_test_dep_fn()));
+    }
+}
diff --git a/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/BUILD.bazel b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/BUILD.bazel
new file mode 100644
index 0000000..64d628e
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/BUILD.bazel
@@ -0,0 +1,20 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "inline",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    # Not all source files are included in this this target (`extra.rs`)
+    # and as a result, rustfmt complains about a missing module. Do not
+    # run rustfmt to avoid this issue.
+    tags = ["norustfmt"],
+)
+
+rust_test(
+    name = "inline_test",
+    srcs = ["src/extra.rs"],
+    crate = ":inline",
+    deps = ["//test/inline_test_with_deps/dep"],
+)
diff --git a/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/extra.rs b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/extra.rs
new file mode 100644
index 0000000..b72dd58
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/extra.rs
@@ -0,0 +1,4 @@
+#[cfg(test)]
+pub(crate) fn extra_test_fn() -> u32 {
+    100
+}
diff --git a/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/lib.rs b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/lib.rs
new file mode 100644
index 0000000..da59d95
--- /dev/null
+++ b/third_party/rules_rust/test/inline_test_with_deps/test_with_srcs/src/lib.rs
@@ -0,0 +1,18 @@
+#[allow(dead_code)]
+fn multiply(val: u32) -> u32 {
+    val * 100
+}
+
+#[cfg(test)]
+mod extra;
+
+#[cfg(test)]
+mod tests {
+    use super::{extra, multiply};
+    use dep::example_test_dep_fn;
+
+    #[test]
+    fn test() {
+        assert_eq!(extra::extra_test_fn(), multiply(example_test_dep_fn()));
+    }
+}
diff --git a/third_party/rules_rust/test/load_arbitrary_tool/BUILD.bazel b/third_party/rules_rust/test/load_arbitrary_tool/BUILD.bazel
new file mode 100644
index 0000000..9479408
--- /dev/null
+++ b/third_party/rules_rust/test/load_arbitrary_tool/BUILD.bazel
@@ -0,0 +1,16 @@
+load("@bazel_skylib//rules:build_test.bzl", "build_test")
+
+filegroup(
+    name = "load_arbitrary_tool_test_src",
+    srcs = select({
+        "//rust/platform:windows": ["@rules_rust_test_load_arbitrary_tool//:bin/cargo.exe"],
+        "//conditions:default": ["@rules_rust_test_load_arbitrary_tool//:bin/cargo"],
+    }),
+)
+
+build_test(
+    name = "load_arbitrary_tool_test",
+    targets = [
+        ":load_arbitrary_tool_test_src",
+    ],
+)
diff --git a/third_party/rules_rust/test/load_arbitrary_tool/load_arbitrary_tool_test.bzl b/third_party/rules_rust/test/load_arbitrary_tool/load_arbitrary_tool_test.bzl
new file mode 100644
index 0000000..8906329
--- /dev/null
+++ b/third_party/rules_rust/test/load_arbitrary_tool/load_arbitrary_tool_test.bzl
@@ -0,0 +1,43 @@
+# buildifier: disable=module-docstring
+load("//rust:repositories.bzl", "load_arbitrary_tool")
+
+def _load_arbitrary_tool_test_impl(repository_ctx):
+    if "mac" in repository_ctx.os.name:
+        target_triple = "x86_64-apple-darwin"
+        cargo_bin = "bin/cargo"
+    elif "windows" in repository_ctx.os.name:
+        target_triple = "x86_64-pc-windows-msvc"
+        cargo_bin = "bin/cargo.exe"
+    else:
+        target_triple = "x86_64-unknown-linux-gnu"
+        cargo_bin = "bin/cargo"
+
+    # Download cargo
+    load_arbitrary_tool(
+        ctx = repository_ctx,
+        tool_name = "cargo",
+        tool_subdirectories = ["cargo"],
+        version = "1.53.0",
+        iso_date = None,
+        target_triple = target_triple,
+    )
+
+    repo_path = repository_ctx.path(".")
+    repository_ctx.file(
+        "{}/BUILD.bazel".format(repo_path),
+        content = "exports_files([\"{}\"])".format(cargo_bin),
+    )
+
+_load_arbitrary_tool_test = repository_rule(
+    implementation = _load_arbitrary_tool_test_impl,
+    doc = (
+        "A test repository rule ensuring `load_arbitrary_tool` functions " +
+        "without requiring any attributes on a repository rule"
+    ),
+)
+
+def load_arbitrary_tool_test():
+    """Define the a test repository for ensuring `load_arbitrary_tool` has no attribute requirements"""
+    _load_arbitrary_tool_test(
+        name = "rules_rust_test_load_arbitrary_tool",
+    )
diff --git a/third_party/rules_rust/test/out_dir_in_tests/BUILD.bazel b/third_party/rules_rust/test/out_dir_in_tests/BUILD.bazel
new file mode 100644
index 0000000..1ee4ce9
--- /dev/null
+++ b/third_party/rules_rust/test/out_dir_in_tests/BUILD.bazel
@@ -0,0 +1,29 @@
+load("//cargo:cargo_build_script.bzl", "cargo_build_script")
+load("//rust:defs.bzl", "rust_library", "rust_test", "rust_test_suite")
+
+cargo_build_script(
+    name = "build_script",
+    srcs = ["build.rs"],
+)
+
+rust_library(
+    name = "demo_lib",
+    srcs = [
+        "src/lib.rs",
+    ],
+    deps = [":build_script"],
+)
+
+rust_test(
+    name = "demo_lib_test",
+    crate = ":demo_lib",
+)
+
+rust_test_suite(
+    name = "suite",
+    srcs = glob(["tests/**"]),
+    # Add the 'crate' argument, which will be passed as a kwarg
+    # to the underlying rust_test rules. This will make OUT_DIR
+    # available when compiling integration tests.
+    crate = ":demo_lib",
+)
diff --git a/third_party/rules_rust/test/out_dir_in_tests/build.rs b/third_party/rules_rust/test/out_dir_in_tests/build.rs
new file mode 100644
index 0000000..f13327a
--- /dev/null
+++ b/third_party/rules_rust/test/out_dir_in_tests/build.rs
@@ -0,0 +1,11 @@
+use std::env;
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::PathBuf;
+
+fn main() -> std::io::Result<()> {
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let mut file = File::create(out_path.join("test_content.txt"))?;
+    file.write_all(b"Test content")?;
+    Ok(())
+}
diff --git a/third_party/rules_rust/test/out_dir_in_tests/src/lib.rs b/third_party/rules_rust/test/out_dir_in_tests/src/lib.rs
new file mode 100644
index 0000000..4eaefdb
--- /dev/null
+++ b/third_party/rules_rust/test/out_dir_in_tests/src/lib.rs
@@ -0,0 +1,18 @@
+#[cfg(test)]
+mod tests {
+    use std::env;
+
+    #[test]
+    fn can_find_the_out_dir_file() {
+        // The file contents must be included via a macro.
+        let contents = include_str!(concat!(env!("OUT_DIR"), "/test_content.txt"));
+        assert_eq!("Test content", contents);
+    }
+
+    #[test]
+    fn no_out_dir_at_runtime() {
+        // Cargo seems to set this at runtime as well, although the documentation
+        // says it's only available at compile time.
+        assert!(env::var("OUT_DIR").is_err());
+    }
+}
diff --git a/third_party/rules_rust/test/out_dir_in_tests/tests/out_dir_reader.rs b/third_party/rules_rust/test/out_dir_in_tests/tests/out_dir_reader.rs
new file mode 100644
index 0000000..9081f0f
--- /dev/null
+++ b/third_party/rules_rust/test/out_dir_in_tests/tests/out_dir_reader.rs
@@ -0,0 +1,15 @@
+use std::env;
+
+#[test]
+fn can_find_the_out_dir_file() {
+    // The file contents must be included via a macro.
+    let contents = include_str!(concat!(env!("OUT_DIR"), "/test_content.txt"));
+    assert_eq!("Test content", contents);
+}
+
+#[test]
+fn no_out_dir_at_runtime() {
+    // Cargo seems to set this at runtime as well, although the documentation
+    // says it's only available at compile time.
+    assert!(env::var("OUT_DIR").is_err());
+}
diff --git a/third_party/rules_rust/test/proc_macro/BUILD.bazel b/third_party/rules_rust/test/proc_macro/BUILD.bazel
new file mode 100644
index 0000000..5a20707
--- /dev/null
+++ b/third_party/rules_rust/test/proc_macro/BUILD.bazel
@@ -0,0 +1,14 @@
+load("//rust:defs.bzl", "rust_test")
+
+[
+    rust_test(
+        name = "proc_macro_{}_integration_test".format(edition),
+        srcs = ["proc_macro_{}_test.rs".format(edition)],
+        edition = edition,
+        proc_macro_deps = ["//test/unit/proc_macro:proc_macro_{}".format(edition)],
+    )
+    for edition in [
+        "2015",
+        "2018",
+    ]
+]
diff --git a/third_party/rules_rust/test/proc_macro/proc_macro_2015_test.rs b/third_party/rules_rust/test/proc_macro/proc_macro_2015_test.rs
new file mode 100644
index 0000000..ef1780d
--- /dev/null
+++ b/third_party/rules_rust/test/proc_macro/proc_macro_2015_test.rs
@@ -0,0 +1,8 @@
+extern crate proc_macro_2015;
+use proc_macro_2015::make_answer;
+
+make_answer!();
+
+fn main() {
+    println!("{}", answer());
+}
diff --git a/third_party/rules_rust/test/proc_macro/proc_macro_2018_test.rs b/third_party/rules_rust/test/proc_macro/proc_macro_2018_test.rs
new file mode 100644
index 0000000..17e44ad
--- /dev/null
+++ b/third_party/rules_rust/test/proc_macro/proc_macro_2018_test.rs
@@ -0,0 +1,8 @@
+use proc_macro_2018::make_answer;
+
+make_answer!();
+
+#[test]
+fn test_answer_macro() {
+    println!("{}", answer());
+}
diff --git a/third_party/rules_rust/test/process_wrapper/BUILD.bazel b/third_party/rules_rust/test/process_wrapper/BUILD.bazel
new file mode 100644
index 0000000..a9f2189
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/BUILD.bazel
@@ -0,0 +1,150 @@
+load("@bazel_skylib//rules:build_test.bzl", "build_test")
+load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("//test/process_wrapper:process_wrapper_tester.bzl", "process_wrapper_tester")
+
+cc_binary(
+    name = "process_wrapper_tester",
+    srcs = [
+        "process_wrapper_tester.cc",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "env_files",
+    srcs = [
+        "test_files/env_file1",
+        "test_files/env_file2",
+        "test_files/env_file3",
+    ],
+)
+
+filegroup(
+    name = "arg_files",
+    srcs = [
+        "test_files/arg_file1",
+        "test_files/arg_file2",
+        "test_files/arg_file3",
+    ],
+)
+
+filegroup(
+    name = "stdout_file",
+    srcs = [
+        "test_files/stdout",
+    ],
+)
+
+filegroup(
+    name = "stderr_file",
+    srcs = [
+        "test_files/stderr",
+    ],
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_basic",
+    test_config = "basic",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_subst_pwd",
+    test_config = "subst-pwd",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_stdout",
+    test_config = "stdout",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_stderr",
+    test_config = "stderr",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_env_files",
+    env_files = [
+        ":env_files",
+    ],
+    test_config = "env-files",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_arg_files",
+    arg_files = [
+        ":arg_files",
+    ],
+    test_config = "arg-files",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_copy_output",
+    test_config = "copy-output",
+)
+
+process_wrapper_tester(
+    name = "process_wrapper_combined",
+    arg_files = [
+        ":arg_files",
+    ],
+    env_files = [
+        ":env_files",
+    ],
+    test_config = "combined",
+)
+
+build_test(
+    name = "basic_test",
+    targets = [
+        ":process_wrapper_basic",
+    ],
+)
+
+build_test(
+    name = "subst_pwd_test",
+    targets = [
+        ":process_wrapper_subst_pwd",
+    ],
+)
+
+diff_test(
+    name = "stdout_test",
+    file1 = ":stdout_file",
+    file2 = ":process_wrapper_stdout",
+)
+
+diff_test(
+    name = "stderr_test",
+    file1 = ":stderr_file",
+    file2 = ":process_wrapper_stderr",
+)
+
+build_test(
+    name = "env_files_test",
+    targets = [
+        ":process_wrapper_env_files",
+    ],
+)
+
+build_test(
+    name = "arg_files_test",
+    targets = [
+        ":process_wrapper_arg_files",
+    ],
+)
+
+build_test(
+    name = "copy_output_test",
+    targets = [
+        ":process_wrapper_copy_output",
+    ],
+)
+
+build_test(
+    name = "combined_test",
+    targets = [
+        ":process_wrapper_combined",
+    ],
+)
diff --git a/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.bzl b/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.bzl
new file mode 100644
index 0000000..9a102a8
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.bzl
@@ -0,0 +1,91 @@
+# Copyright 2020 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+"""Process wrapper test.
+
+This rule unit tests the different process_wrapper functionality.
+"""
+
+def _impl(ctx):
+    args = ctx.actions.args()
+    outputs = []
+    combined = ctx.attr.test_config == "combined"
+
+    if combined or ctx.attr.test_config == "stdout":
+        stdout_output = ctx.actions.declare_file(ctx.label.name + ".stdout")
+        outputs.append(stdout_output)
+        args.add("--stdout-file", stdout_output.path)
+
+    if combined or ctx.attr.test_config == "stderr":
+        stderr_output = ctx.actions.declare_file(ctx.label.name + ".stderr")
+        outputs.append(stderr_output)
+        args.add("--stderr-file", stderr_output.path)
+
+    if combined or (ctx.attr.test_config != "stdout" and ctx.attr.test_config != "stderr"):
+        touch_output = ctx.actions.declare_file(ctx.label.name + ".touch")
+        outputs.append(touch_output)
+        args.add("--touch-file", touch_output.path)
+        if ctx.attr.test_config == "copy-output":
+            copy_output = ctx.actions.declare_file(ctx.label.name + ".touch.copy")
+            outputs.append(copy_output)
+            args.add_all("--copy-output", [touch_output.path, copy_output.path])
+
+    if combined or ctx.attr.test_config == "env-files":
+        args.add_all(ctx.files.env_files, before_each = "--env-file")
+
+    if combined or ctx.attr.test_config == "arg-files":
+        args.add_all(ctx.files.arg_files, before_each = "--arg-file")
+
+    if combined or ctx.attr.test_config == "subst-pwd":
+        args.add("--subst", "pwd=${pwd}")
+        args.add("--subst", "key=value")
+
+    args.add("--")
+
+    args.add(ctx.executable._process_wrapper_tester.path)
+    args.add(ctx.attr.test_config)
+    args.add("--current-dir", "${pwd}")
+    args.add("--test-subst", "subst key to ${key}")
+    env = {"CURRENT_DIR": "${pwd}/test_path"}
+
+    ctx.actions.run(
+        executable = ctx.executable._process_wrapper,
+        inputs = ctx.files.env_files + ctx.files.arg_files,
+        outputs = outputs,
+        arguments = [args],
+        env = env,
+        tools = [ctx.executable._process_wrapper_tester],
+    )
+
+    return [DefaultInfo(files = depset(outputs))]
+
+process_wrapper_tester = rule(
+    implementation = _impl,
+    attrs = {
+        "arg_files": attr.label_list(),
+        "env_files": attr.label_list(),
+        "test_config": attr.string(mandatory = True),
+        "_process_wrapper": attr.label(
+            default = Label("//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+        "_process_wrapper_tester": attr.label(
+            default = "//test/process_wrapper:process_wrapper_tester",
+            executable = True,
+            cfg = "exec",
+        ),
+    },
+)
diff --git a/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.cc b/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.cc
new file mode 100644
index 0000000..7cf1c02
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/process_wrapper_tester.cc
@@ -0,0 +1,171 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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 <cstdlib>
+#include <iostream>
+#include <string>
+
+void basic_part1_test(std::string current_dir_arg) {
+  if (current_dir_arg != "--current-dir") {
+    std::cerr << "error: argument \"--current-dir\" not found.\n";
+    std::exit(1);
+  }
+}
+
+void basic_part2_test(std::string current_dir, const char* envp[]) {
+  if (current_dir != "${pwd}") {
+    std::cerr << "error: unsubsituted ${pwd} not found.\n";
+    std::exit(1);
+  }
+  const std::string current_dir_env = "CURRENT_DIR=${pwd}/test_path";
+  bool found = false;
+  for (int i = 0; envp[i] != nullptr; ++i) {
+    if (current_dir_env == envp[i]) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    std::cerr << "unsubsituted CURRENT_DIR not found.\n";
+    std::exit(1);
+  }
+}
+
+void subst_pwd_test(std::string current_dir, const char* envp[]) {
+  if (current_dir.find("${pwd}") != std::string::npos) {
+    std::cerr << "error: argument ${pwd} substitution failed.\n";
+    std::exit(1);
+  }
+  bool found = false;
+  for (int i = 0; envp[i] != nullptr; ++i) {
+    const std::string env = envp[i];
+    if (env.rfind("CURRENT_DIR", 0) == 0) {
+      found = true;
+      if (env.find("${pwd}") != std::string::npos) {
+        std::cerr << "error: environment variable ${pwd} substitution failed.\n";
+        std::exit(1);
+      }
+      break;
+    }
+  }
+  if (!found) {
+    std::cerr << "CURRENT_DIR not found.\n";
+    std::exit(1);
+  }
+}
+
+void env_files_test(const char* envp[]) {
+  const std::string must_exist[] = {
+      "FOO=BAR",
+      "FOOBAR=BARFOO",
+      "BAR=FOO",
+      "ENV_ESCAPE=with\nnew line",
+      "ENV_NO_ESCAPE=with no new line\\",
+      "ENV_ESCAPE_WITH_BACKSLASH=new line\\\nhere",
+  };
+  for (const std::string& env : must_exist) {
+    bool found = false;
+    for (int i = 0; envp[i] != nullptr; ++i) {
+      if (env == envp[i]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      std::cerr << "error: environment variable \"" << env << "\" not found.\n";
+      std::exit(1);
+    }
+  }
+}
+
+void arg_files_test(int argc, const char* argv[]) {
+  const std::string must_exist[] = {
+      "--arg1=foo",
+      "--arg2",
+      "foo bar",
+      "--arg2=bar",
+      "--arg3",
+      "foobar",
+      "arg with\nnew line",
+      "arg with\\",
+      "no new line",
+      "arg with\\\nnew line and a trailing backslash",
+  };
+
+  for (const std::string& arg : must_exist) {
+    bool found = false;
+    for (int i = 0; i < argc; ++i) {
+      if (arg == argv[i]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      std::cerr << "error: argument \"" << arg << "\" not found.\n";
+      std::exit(1);
+    }
+  }
+}
+
+void test_stdout() {
+  for (int i = 0; i < 10000; ++i) {
+// On windows writing LF to any stream in text mode gets changed to CRLF
+// Since the test file is saved using CRLF, we are forcing the same on
+// non windows systems
+#if defined(_WIN32)
+    std::cout << "Child process to stdout : " << i << "\n";
+#else
+    std::cout << "Child process to stdout : " << i << "\r\n";
+#endif  // defined(_WIN32)
+  }
+}
+
+void test_stderr() {
+  std::cerr << "This is the stderr output";
+}
+
+int main(int argc, const char* argv[], const char* envp[]) {
+  if (argc < 4) {
+    std::cerr << "error: Invalid number of args exected at least 4 got " << argc
+              << ".\n";
+    return 1;
+  }
+  std::string test_config = argv[1];
+  bool combined = test_config == "combined";
+  if (combined || test_config == "basic") {
+    basic_part1_test(argv[2]);
+  }
+
+  if (combined || test_config == "subst-pwd") {
+    subst_pwd_test(argv[3], envp);
+  } else if (test_config == "basic") {
+    basic_part2_test(argv[3], envp);
+  }
+
+  if (combined || test_config == "env-files") {
+    env_files_test(envp);
+  }
+
+  if (combined || test_config == "arg-files") {
+    arg_files_test(argc, argv);
+  }
+
+  if (combined || test_config == "stdout") {
+    test_stdout();
+  }
+
+  if (combined || test_config == "stderr") {
+    test_stderr();
+  }
+}
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/arg_file1 b/third_party/rules_rust/test/process_wrapper/test_files/arg_file1
new file mode 100644
index 0000000..a231805
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/arg_file1
@@ -0,0 +1,3 @@
+--arg1=foo
+--arg2
+foo bar
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/arg_file2 b/third_party/rules_rust/test/process_wrapper/test_files/arg_file2
new file mode 100644
index 0000000..8a952a8
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/arg_file2
@@ -0,0 +1,4 @@
+--arg2=bar
+--arg3
+foobar
+
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/arg_file3 b/third_party/rules_rust/test/process_wrapper/test_files/arg_file3
new file mode 100644
index 0000000..942f0d2
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/arg_file3
@@ -0,0 +1,6 @@
+arg with\
+new line
+arg with\\
+no new line
+arg with\\\
+new line and a trailing backslash
\ No newline at end of file
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/env_file1 b/third_party/rules_rust/test/process_wrapper/test_files/env_file1
new file mode 100644
index 0000000..51cce6b
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/env_file1
@@ -0,0 +1,2 @@
+FOO=BAR
+FOOBAR=BARFOO
\ No newline at end of file
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/env_file2 b/third_party/rules_rust/test/process_wrapper/test_files/env_file2
new file mode 100644
index 0000000..ff8d11e
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/env_file2
@@ -0,0 +1,2 @@
+BAR=FOO
+
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/env_file3 b/third_party/rules_rust/test/process_wrapper/test_files/env_file3
new file mode 100644
index 0000000..675d27b
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/env_file3
@@ -0,0 +1,5 @@
+ENV_ESCAPE=with\
+new line
+ENV_NO_ESCAPE=with no new line\\
+ENV_ESCAPE_WITH_BACKSLASH=new line\\\
+here
\ No newline at end of file
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/stderr b/third_party/rules_rust/test/process_wrapper/test_files/stderr
new file mode 100644
index 0000000..f93e11d
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/stderr
@@ -0,0 +1 @@
+This is the stderr output
\ No newline at end of file
diff --git a/third_party/rules_rust/test/process_wrapper/test_files/stdout b/third_party/rules_rust/test/process_wrapper/test_files/stdout
new file mode 100644
index 0000000..7dbde5a
--- /dev/null
+++ b/third_party/rules_rust/test/process_wrapper/test_files/stdout
@@ -0,0 +1,10000 @@
+Child process to stdout : 0
+Child process to stdout : 1
+Child process to stdout : 2
+Child process to stdout : 3
+Child process to stdout : 4
+Child process to stdout : 5
+Child process to stdout : 6
+Child process to stdout : 7
+Child process to stdout : 8
+Child process to stdout : 9
+Child process to stdout : 10
+Child process to stdout : 11
+Child process to stdout : 12
+Child process to stdout : 13
+Child process to stdout : 14
+Child process to stdout : 15
+Child process to stdout : 16
+Child process to stdout : 17
+Child process to stdout : 18
+Child process to stdout : 19
+Child process to stdout : 20
+Child process to stdout : 21
+Child process to stdout : 22
+Child process to stdout : 23
+Child process to stdout : 24
+Child process to stdout : 25
+Child process to stdout : 26
+Child process to stdout : 27
+Child process to stdout : 28
+Child process to stdout : 29
+Child process to stdout : 30
+Child process to stdout : 31
+Child process to stdout : 32
+Child process to stdout : 33
+Child process to stdout : 34
+Child process to stdout : 35
+Child process to stdout : 36
+Child process to stdout : 37
+Child process to stdout : 38
+Child process to stdout : 39
+Child process to stdout : 40
+Child process to stdout : 41
+Child process to stdout : 42
+Child process to stdout : 43
+Child process to stdout : 44
+Child process to stdout : 45
+Child process to stdout : 46
+Child process to stdout : 47
+Child process to stdout : 48
+Child process to stdout : 49
+Child process to stdout : 50
+Child process to stdout : 51
+Child process to stdout : 52
+Child process to stdout : 53
+Child process to stdout : 54
+Child process to stdout : 55
+Child process to stdout : 56
+Child process to stdout : 57
+Child process to stdout : 58
+Child process to stdout : 59
+Child process to stdout : 60
+Child process to stdout : 61
+Child process to stdout : 62
+Child process to stdout : 63
+Child process to stdout : 64
+Child process to stdout : 65
+Child process to stdout : 66
+Child process to stdout : 67
+Child process to stdout : 68
+Child process to stdout : 69
+Child process to stdout : 70
+Child process to stdout : 71
+Child process to stdout : 72
+Child process to stdout : 73
+Child process to stdout : 74
+Child process to stdout : 75
+Child process to stdout : 76
+Child process to stdout : 77
+Child process to stdout : 78
+Child process to stdout : 79
+Child process to stdout : 80
+Child process to stdout : 81
+Child process to stdout : 82
+Child process to stdout : 83
+Child process to stdout : 84
+Child process to stdout : 85
+Child process to stdout : 86
+Child process to stdout : 87
+Child process to stdout : 88
+Child process to stdout : 89
+Child process to stdout : 90
+Child process to stdout : 91
+Child process to stdout : 92
+Child process to stdout : 93
+Child process to stdout : 94
+Child process to stdout : 95
+Child process to stdout : 96
+Child process to stdout : 97
+Child process to stdout : 98
+Child process to stdout : 99
+Child process to stdout : 100
+Child process to stdout : 101
+Child process to stdout : 102
+Child process to stdout : 103
+Child process to stdout : 104
+Child process to stdout : 105
+Child process to stdout : 106
+Child process to stdout : 107
+Child process to stdout : 108
+Child process to stdout : 109
+Child process to stdout : 110
+Child process to stdout : 111
+Child process to stdout : 112
+Child process to stdout : 113
+Child process to stdout : 114
+Child process to stdout : 115
+Child process to stdout : 116
+Child process to stdout : 117
+Child process to stdout : 118
+Child process to stdout : 119
+Child process to stdout : 120
+Child process to stdout : 121
+Child process to stdout : 122
+Child process to stdout : 123
+Child process to stdout : 124
+Child process to stdout : 125
+Child process to stdout : 126
+Child process to stdout : 127
+Child process to stdout : 128
+Child process to stdout : 129
+Child process to stdout : 130
+Child process to stdout : 131
+Child process to stdout : 132
+Child process to stdout : 133
+Child process to stdout : 134
+Child process to stdout : 135
+Child process to stdout : 136
+Child process to stdout : 137
+Child process to stdout : 138
+Child process to stdout : 139
+Child process to stdout : 140
+Child process to stdout : 141
+Child process to stdout : 142
+Child process to stdout : 143
+Child process to stdout : 144
+Child process to stdout : 145
+Child process to stdout : 146
+Child process to stdout : 147
+Child process to stdout : 148
+Child process to stdout : 149
+Child process to stdout : 150
+Child process to stdout : 151
+Child process to stdout : 152
+Child process to stdout : 153
+Child process to stdout : 154
+Child process to stdout : 155
+Child process to stdout : 156
+Child process to stdout : 157
+Child process to stdout : 158
+Child process to stdout : 159
+Child process to stdout : 160
+Child process to stdout : 161
+Child process to stdout : 162
+Child process to stdout : 163
+Child process to stdout : 164
+Child process to stdout : 165
+Child process to stdout : 166
+Child process to stdout : 167
+Child process to stdout : 168
+Child process to stdout : 169
+Child process to stdout : 170
+Child process to stdout : 171
+Child process to stdout : 172
+Child process to stdout : 173
+Child process to stdout : 174
+Child process to stdout : 175
+Child process to stdout : 176
+Child process to stdout : 177
+Child process to stdout : 178
+Child process to stdout : 179
+Child process to stdout : 180
+Child process to stdout : 181
+Child process to stdout : 182
+Child process to stdout : 183
+Child process to stdout : 184
+Child process to stdout : 185
+Child process to stdout : 186
+Child process to stdout : 187
+Child process to stdout : 188
+Child process to stdout : 189
+Child process to stdout : 190
+Child process to stdout : 191
+Child process to stdout : 192
+Child process to stdout : 193
+Child process to stdout : 194
+Child process to stdout : 195
+Child process to stdout : 196
+Child process to stdout : 197
+Child process to stdout : 198
+Child process to stdout : 199
+Child process to stdout : 200
+Child process to stdout : 201
+Child process to stdout : 202
+Child process to stdout : 203
+Child process to stdout : 204
+Child process to stdout : 205
+Child process to stdout : 206
+Child process to stdout : 207
+Child process to stdout : 208
+Child process to stdout : 209
+Child process to stdout : 210
+Child process to stdout : 211
+Child process to stdout : 212
+Child process to stdout : 213
+Child process to stdout : 214
+Child process to stdout : 215
+Child process to stdout : 216
+Child process to stdout : 217
+Child process to stdout : 218
+Child process to stdout : 219
+Child process to stdout : 220
+Child process to stdout : 221
+Child process to stdout : 222
+Child process to stdout : 223
+Child process to stdout : 224
+Child process to stdout : 225
+Child process to stdout : 226
+Child process to stdout : 227
+Child process to stdout : 228
+Child process to stdout : 229
+Child process to stdout : 230
+Child process to stdout : 231
+Child process to stdout : 232
+Child process to stdout : 233
+Child process to stdout : 234
+Child process to stdout : 235
+Child process to stdout : 236
+Child process to stdout : 237
+Child process to stdout : 238
+Child process to stdout : 239
+Child process to stdout : 240
+Child process to stdout : 241
+Child process to stdout : 242
+Child process to stdout : 243
+Child process to stdout : 244
+Child process to stdout : 245
+Child process to stdout : 246
+Child process to stdout : 247
+Child process to stdout : 248
+Child process to stdout : 249
+Child process to stdout : 250
+Child process to stdout : 251
+Child process to stdout : 252
+Child process to stdout : 253
+Child process to stdout : 254
+Child process to stdout : 255
+Child process to stdout : 256
+Child process to stdout : 257
+Child process to stdout : 258
+Child process to stdout : 259
+Child process to stdout : 260
+Child process to stdout : 261
+Child process to stdout : 262
+Child process to stdout : 263
+Child process to stdout : 264
+Child process to stdout : 265
+Child process to stdout : 266
+Child process to stdout : 267
+Child process to stdout : 268
+Child process to stdout : 269
+Child process to stdout : 270
+Child process to stdout : 271
+Child process to stdout : 272
+Child process to stdout : 273
+Child process to stdout : 274
+Child process to stdout : 275
+Child process to stdout : 276
+Child process to stdout : 277
+Child process to stdout : 278
+Child process to stdout : 279
+Child process to stdout : 280
+Child process to stdout : 281
+Child process to stdout : 282
+Child process to stdout : 283
+Child process to stdout : 284
+Child process to stdout : 285
+Child process to stdout : 286
+Child process to stdout : 287
+Child process to stdout : 288
+Child process to stdout : 289
+Child process to stdout : 290
+Child process to stdout : 291
+Child process to stdout : 292
+Child process to stdout : 293
+Child process to stdout : 294
+Child process to stdout : 295
+Child process to stdout : 296
+Child process to stdout : 297
+Child process to stdout : 298
+Child process to stdout : 299
+Child process to stdout : 300
+Child process to stdout : 301
+Child process to stdout : 302
+Child process to stdout : 303
+Child process to stdout : 304
+Child process to stdout : 305
+Child process to stdout : 306
+Child process to stdout : 307
+Child process to stdout : 308
+Child process to stdout : 309
+Child process to stdout : 310
+Child process to stdout : 311
+Child process to stdout : 312
+Child process to stdout : 313
+Child process to stdout : 314
+Child process to stdout : 315
+Child process to stdout : 316
+Child process to stdout : 317
+Child process to stdout : 318
+Child process to stdout : 319
+Child process to stdout : 320
+Child process to stdout : 321
+Child process to stdout : 322
+Child process to stdout : 323
+Child process to stdout : 324
+Child process to stdout : 325
+Child process to stdout : 326
+Child process to stdout : 327
+Child process to stdout : 328
+Child process to stdout : 329
+Child process to stdout : 330
+Child process to stdout : 331
+Child process to stdout : 332
+Child process to stdout : 333
+Child process to stdout : 334
+Child process to stdout : 335
+Child process to stdout : 336
+Child process to stdout : 337
+Child process to stdout : 338
+Child process to stdout : 339
+Child process to stdout : 340
+Child process to stdout : 341
+Child process to stdout : 342
+Child process to stdout : 343
+Child process to stdout : 344
+Child process to stdout : 345
+Child process to stdout : 346
+Child process to stdout : 347
+Child process to stdout : 348
+Child process to stdout : 349
+Child process to stdout : 350
+Child process to stdout : 351
+Child process to stdout : 352
+Child process to stdout : 353
+Child process to stdout : 354
+Child process to stdout : 355
+Child process to stdout : 356
+Child process to stdout : 357
+Child process to stdout : 358
+Child process to stdout : 359
+Child process to stdout : 360
+Child process to stdout : 361
+Child process to stdout : 362
+Child process to stdout : 363
+Child process to stdout : 364
+Child process to stdout : 365
+Child process to stdout : 366
+Child process to stdout : 367
+Child process to stdout : 368
+Child process to stdout : 369
+Child process to stdout : 370
+Child process to stdout : 371
+Child process to stdout : 372
+Child process to stdout : 373
+Child process to stdout : 374
+Child process to stdout : 375
+Child process to stdout : 376
+Child process to stdout : 377
+Child process to stdout : 378
+Child process to stdout : 379
+Child process to stdout : 380
+Child process to stdout : 381
+Child process to stdout : 382
+Child process to stdout : 383
+Child process to stdout : 384
+Child process to stdout : 385
+Child process to stdout : 386
+Child process to stdout : 387
+Child process to stdout : 388
+Child process to stdout : 389
+Child process to stdout : 390
+Child process to stdout : 391
+Child process to stdout : 392
+Child process to stdout : 393
+Child process to stdout : 394
+Child process to stdout : 395
+Child process to stdout : 396
+Child process to stdout : 397
+Child process to stdout : 398
+Child process to stdout : 399
+Child process to stdout : 400
+Child process to stdout : 401
+Child process to stdout : 402
+Child process to stdout : 403
+Child process to stdout : 404
+Child process to stdout : 405
+Child process to stdout : 406
+Child process to stdout : 407
+Child process to stdout : 408
+Child process to stdout : 409
+Child process to stdout : 410
+Child process to stdout : 411
+Child process to stdout : 412
+Child process to stdout : 413
+Child process to stdout : 414
+Child process to stdout : 415
+Child process to stdout : 416
+Child process to stdout : 417
+Child process to stdout : 418
+Child process to stdout : 419
+Child process to stdout : 420
+Child process to stdout : 421
+Child process to stdout : 422
+Child process to stdout : 423
+Child process to stdout : 424
+Child process to stdout : 425
+Child process to stdout : 426
+Child process to stdout : 427
+Child process to stdout : 428
+Child process to stdout : 429
+Child process to stdout : 430
+Child process to stdout : 431
+Child process to stdout : 432
+Child process to stdout : 433
+Child process to stdout : 434
+Child process to stdout : 435
+Child process to stdout : 436
+Child process to stdout : 437
+Child process to stdout : 438
+Child process to stdout : 439
+Child process to stdout : 440
+Child process to stdout : 441
+Child process to stdout : 442
+Child process to stdout : 443
+Child process to stdout : 444
+Child process to stdout : 445
+Child process to stdout : 446
+Child process to stdout : 447
+Child process to stdout : 448
+Child process to stdout : 449
+Child process to stdout : 450
+Child process to stdout : 451
+Child process to stdout : 452
+Child process to stdout : 453
+Child process to stdout : 454
+Child process to stdout : 455
+Child process to stdout : 456
+Child process to stdout : 457
+Child process to stdout : 458
+Child process to stdout : 459
+Child process to stdout : 460
+Child process to stdout : 461
+Child process to stdout : 462
+Child process to stdout : 463
+Child process to stdout : 464
+Child process to stdout : 465
+Child process to stdout : 466
+Child process to stdout : 467
+Child process to stdout : 468
+Child process to stdout : 469
+Child process to stdout : 470
+Child process to stdout : 471
+Child process to stdout : 472
+Child process to stdout : 473
+Child process to stdout : 474
+Child process to stdout : 475
+Child process to stdout : 476
+Child process to stdout : 477
+Child process to stdout : 478
+Child process to stdout : 479
+Child process to stdout : 480
+Child process to stdout : 481
+Child process to stdout : 482
+Child process to stdout : 483
+Child process to stdout : 484
+Child process to stdout : 485
+Child process to stdout : 486
+Child process to stdout : 487
+Child process to stdout : 488
+Child process to stdout : 489
+Child process to stdout : 490
+Child process to stdout : 491
+Child process to stdout : 492
+Child process to stdout : 493
+Child process to stdout : 494
+Child process to stdout : 495
+Child process to stdout : 496
+Child process to stdout : 497
+Child process to stdout : 498
+Child process to stdout : 499
+Child process to stdout : 500
+Child process to stdout : 501
+Child process to stdout : 502
+Child process to stdout : 503
+Child process to stdout : 504
+Child process to stdout : 505
+Child process to stdout : 506
+Child process to stdout : 507
+Child process to stdout : 508
+Child process to stdout : 509
+Child process to stdout : 510
+Child process to stdout : 511
+Child process to stdout : 512
+Child process to stdout : 513
+Child process to stdout : 514
+Child process to stdout : 515
+Child process to stdout : 516
+Child process to stdout : 517
+Child process to stdout : 518
+Child process to stdout : 519
+Child process to stdout : 520
+Child process to stdout : 521
+Child process to stdout : 522
+Child process to stdout : 523
+Child process to stdout : 524
+Child process to stdout : 525
+Child process to stdout : 526
+Child process to stdout : 527
+Child process to stdout : 528
+Child process to stdout : 529
+Child process to stdout : 530
+Child process to stdout : 531
+Child process to stdout : 532
+Child process to stdout : 533
+Child process to stdout : 534
+Child process to stdout : 535
+Child process to stdout : 536
+Child process to stdout : 537
+Child process to stdout : 538
+Child process to stdout : 539
+Child process to stdout : 540
+Child process to stdout : 541
+Child process to stdout : 542
+Child process to stdout : 543
+Child process to stdout : 544
+Child process to stdout : 545
+Child process to stdout : 546
+Child process to stdout : 547
+Child process to stdout : 548
+Child process to stdout : 549
+Child process to stdout : 550
+Child process to stdout : 551
+Child process to stdout : 552
+Child process to stdout : 553
+Child process to stdout : 554
+Child process to stdout : 555
+Child process to stdout : 556
+Child process to stdout : 557
+Child process to stdout : 558
+Child process to stdout : 559
+Child process to stdout : 560
+Child process to stdout : 561
+Child process to stdout : 562
+Child process to stdout : 563
+Child process to stdout : 564
+Child process to stdout : 565
+Child process to stdout : 566
+Child process to stdout : 567
+Child process to stdout : 568
+Child process to stdout : 569
+Child process to stdout : 570
+Child process to stdout : 571
+Child process to stdout : 572
+Child process to stdout : 573
+Child process to stdout : 574
+Child process to stdout : 575
+Child process to stdout : 576
+Child process to stdout : 577
+Child process to stdout : 578
+Child process to stdout : 579
+Child process to stdout : 580
+Child process to stdout : 581
+Child process to stdout : 582
+Child process to stdout : 583
+Child process to stdout : 584
+Child process to stdout : 585
+Child process to stdout : 586
+Child process to stdout : 587
+Child process to stdout : 588
+Child process to stdout : 589
+Child process to stdout : 590
+Child process to stdout : 591
+Child process to stdout : 592
+Child process to stdout : 593
+Child process to stdout : 594
+Child process to stdout : 595
+Child process to stdout : 596
+Child process to stdout : 597
+Child process to stdout : 598
+Child process to stdout : 599
+Child process to stdout : 600
+Child process to stdout : 601
+Child process to stdout : 602
+Child process to stdout : 603
+Child process to stdout : 604
+Child process to stdout : 605
+Child process to stdout : 606
+Child process to stdout : 607
+Child process to stdout : 608
+Child process to stdout : 609
+Child process to stdout : 610
+Child process to stdout : 611
+Child process to stdout : 612
+Child process to stdout : 613
+Child process to stdout : 614
+Child process to stdout : 615
+Child process to stdout : 616
+Child process to stdout : 617
+Child process to stdout : 618
+Child process to stdout : 619
+Child process to stdout : 620
+Child process to stdout : 621
+Child process to stdout : 622
+Child process to stdout : 623
+Child process to stdout : 624
+Child process to stdout : 625
+Child process to stdout : 626
+Child process to stdout : 627
+Child process to stdout : 628
+Child process to stdout : 629
+Child process to stdout : 630
+Child process to stdout : 631
+Child process to stdout : 632
+Child process to stdout : 633
+Child process to stdout : 634
+Child process to stdout : 635
+Child process to stdout : 636
+Child process to stdout : 637
+Child process to stdout : 638
+Child process to stdout : 639
+Child process to stdout : 640
+Child process to stdout : 641
+Child process to stdout : 642
+Child process to stdout : 643
+Child process to stdout : 644
+Child process to stdout : 645
+Child process to stdout : 646
+Child process to stdout : 647
+Child process to stdout : 648
+Child process to stdout : 649
+Child process to stdout : 650
+Child process to stdout : 651
+Child process to stdout : 652
+Child process to stdout : 653
+Child process to stdout : 654
+Child process to stdout : 655
+Child process to stdout : 656
+Child process to stdout : 657
+Child process to stdout : 658
+Child process to stdout : 659
+Child process to stdout : 660
+Child process to stdout : 661
+Child process to stdout : 662
+Child process to stdout : 663
+Child process to stdout : 664
+Child process to stdout : 665
+Child process to stdout : 666
+Child process to stdout : 667
+Child process to stdout : 668
+Child process to stdout : 669
+Child process to stdout : 670
+Child process to stdout : 671
+Child process to stdout : 672
+Child process to stdout : 673
+Child process to stdout : 674
+Child process to stdout : 675
+Child process to stdout : 676
+Child process to stdout : 677
+Child process to stdout : 678
+Child process to stdout : 679
+Child process to stdout : 680
+Child process to stdout : 681
+Child process to stdout : 682
+Child process to stdout : 683
+Child process to stdout : 684
+Child process to stdout : 685
+Child process to stdout : 686
+Child process to stdout : 687
+Child process to stdout : 688
+Child process to stdout : 689
+Child process to stdout : 690
+Child process to stdout : 691
+Child process to stdout : 692
+Child process to stdout : 693
+Child process to stdout : 694
+Child process to stdout : 695
+Child process to stdout : 696
+Child process to stdout : 697
+Child process to stdout : 698
+Child process to stdout : 699
+Child process to stdout : 700
+Child process to stdout : 701
+Child process to stdout : 702
+Child process to stdout : 703
+Child process to stdout : 704
+Child process to stdout : 705
+Child process to stdout : 706
+Child process to stdout : 707
+Child process to stdout : 708
+Child process to stdout : 709
+Child process to stdout : 710
+Child process to stdout : 711
+Child process to stdout : 712
+Child process to stdout : 713
+Child process to stdout : 714
+Child process to stdout : 715
+Child process to stdout : 716
+Child process to stdout : 717
+Child process to stdout : 718
+Child process to stdout : 719
+Child process to stdout : 720
+Child process to stdout : 721
+Child process to stdout : 722
+Child process to stdout : 723
+Child process to stdout : 724
+Child process to stdout : 725
+Child process to stdout : 726
+Child process to stdout : 727
+Child process to stdout : 728
+Child process to stdout : 729
+Child process to stdout : 730
+Child process to stdout : 731
+Child process to stdout : 732
+Child process to stdout : 733
+Child process to stdout : 734
+Child process to stdout : 735
+Child process to stdout : 736
+Child process to stdout : 737
+Child process to stdout : 738
+Child process to stdout : 739
+Child process to stdout : 740
+Child process to stdout : 741
+Child process to stdout : 742
+Child process to stdout : 743
+Child process to stdout : 744
+Child process to stdout : 745
+Child process to stdout : 746
+Child process to stdout : 747
+Child process to stdout : 748
+Child process to stdout : 749
+Child process to stdout : 750
+Child process to stdout : 751
+Child process to stdout : 752
+Child process to stdout : 753
+Child process to stdout : 754
+Child process to stdout : 755
+Child process to stdout : 756
+Child process to stdout : 757
+Child process to stdout : 758
+Child process to stdout : 759
+Child process to stdout : 760
+Child process to stdout : 761
+Child process to stdout : 762
+Child process to stdout : 763
+Child process to stdout : 764
+Child process to stdout : 765
+Child process to stdout : 766
+Child process to stdout : 767
+Child process to stdout : 768
+Child process to stdout : 769
+Child process to stdout : 770
+Child process to stdout : 771
+Child process to stdout : 772
+Child process to stdout : 773
+Child process to stdout : 774
+Child process to stdout : 775
+Child process to stdout : 776
+Child process to stdout : 777
+Child process to stdout : 778
+Child process to stdout : 779
+Child process to stdout : 780
+Child process to stdout : 781
+Child process to stdout : 782
+Child process to stdout : 783
+Child process to stdout : 784
+Child process to stdout : 785
+Child process to stdout : 786
+Child process to stdout : 787
+Child process to stdout : 788
+Child process to stdout : 789
+Child process to stdout : 790
+Child process to stdout : 791
+Child process to stdout : 792
+Child process to stdout : 793
+Child process to stdout : 794
+Child process to stdout : 795
+Child process to stdout : 796
+Child process to stdout : 797
+Child process to stdout : 798
+Child process to stdout : 799
+Child process to stdout : 800
+Child process to stdout : 801
+Child process to stdout : 802
+Child process to stdout : 803
+Child process to stdout : 804
+Child process to stdout : 805
+Child process to stdout : 806
+Child process to stdout : 807
+Child process to stdout : 808
+Child process to stdout : 809
+Child process to stdout : 810
+Child process to stdout : 811
+Child process to stdout : 812
+Child process to stdout : 813
+Child process to stdout : 814
+Child process to stdout : 815
+Child process to stdout : 816
+Child process to stdout : 817
+Child process to stdout : 818
+Child process to stdout : 819
+Child process to stdout : 820
+Child process to stdout : 821
+Child process to stdout : 822
+Child process to stdout : 823
+Child process to stdout : 824
+Child process to stdout : 825
+Child process to stdout : 826
+Child process to stdout : 827
+Child process to stdout : 828
+Child process to stdout : 829
+Child process to stdout : 830
+Child process to stdout : 831
+Child process to stdout : 832
+Child process to stdout : 833
+Child process to stdout : 834
+Child process to stdout : 835
+Child process to stdout : 836
+Child process to stdout : 837
+Child process to stdout : 838
+Child process to stdout : 839
+Child process to stdout : 840
+Child process to stdout : 841
+Child process to stdout : 842
+Child process to stdout : 843
+Child process to stdout : 844
+Child process to stdout : 845
+Child process to stdout : 846
+Child process to stdout : 847
+Child process to stdout : 848
+Child process to stdout : 849
+Child process to stdout : 850
+Child process to stdout : 851
+Child process to stdout : 852
+Child process to stdout : 853
+Child process to stdout : 854
+Child process to stdout : 855
+Child process to stdout : 856
+Child process to stdout : 857
+Child process to stdout : 858
+Child process to stdout : 859
+Child process to stdout : 860
+Child process to stdout : 861
+Child process to stdout : 862
+Child process to stdout : 863
+Child process to stdout : 864
+Child process to stdout : 865
+Child process to stdout : 866
+Child process to stdout : 867
+Child process to stdout : 868
+Child process to stdout : 869
+Child process to stdout : 870
+Child process to stdout : 871
+Child process to stdout : 872
+Child process to stdout : 873
+Child process to stdout : 874
+Child process to stdout : 875
+Child process to stdout : 876
+Child process to stdout : 877
+Child process to stdout : 878
+Child process to stdout : 879
+Child process to stdout : 880
+Child process to stdout : 881
+Child process to stdout : 882
+Child process to stdout : 883
+Child process to stdout : 884
+Child process to stdout : 885
+Child process to stdout : 886
+Child process to stdout : 887
+Child process to stdout : 888
+Child process to stdout : 889
+Child process to stdout : 890
+Child process to stdout : 891
+Child process to stdout : 892
+Child process to stdout : 893
+Child process to stdout : 894
+Child process to stdout : 895
+Child process to stdout : 896
+Child process to stdout : 897
+Child process to stdout : 898
+Child process to stdout : 899
+Child process to stdout : 900
+Child process to stdout : 901
+Child process to stdout : 902
+Child process to stdout : 903
+Child process to stdout : 904
+Child process to stdout : 905
+Child process to stdout : 906
+Child process to stdout : 907
+Child process to stdout : 908
+Child process to stdout : 909
+Child process to stdout : 910
+Child process to stdout : 911
+Child process to stdout : 912
+Child process to stdout : 913
+Child process to stdout : 914
+Child process to stdout : 915
+Child process to stdout : 916
+Child process to stdout : 917
+Child process to stdout : 918
+Child process to stdout : 919
+Child process to stdout : 920
+Child process to stdout : 921
+Child process to stdout : 922
+Child process to stdout : 923
+Child process to stdout : 924
+Child process to stdout : 925
+Child process to stdout : 926
+Child process to stdout : 927
+Child process to stdout : 928
+Child process to stdout : 929
+Child process to stdout : 930
+Child process to stdout : 931
+Child process to stdout : 932
+Child process to stdout : 933
+Child process to stdout : 934
+Child process to stdout : 935
+Child process to stdout : 936
+Child process to stdout : 937
+Child process to stdout : 938
+Child process to stdout : 939
+Child process to stdout : 940
+Child process to stdout : 941
+Child process to stdout : 942
+Child process to stdout : 943
+Child process to stdout : 944
+Child process to stdout : 945
+Child process to stdout : 946
+Child process to stdout : 947
+Child process to stdout : 948
+Child process to stdout : 949
+Child process to stdout : 950
+Child process to stdout : 951
+Child process to stdout : 952
+Child process to stdout : 953
+Child process to stdout : 954
+Child process to stdout : 955
+Child process to stdout : 956
+Child process to stdout : 957
+Child process to stdout : 958
+Child process to stdout : 959
+Child process to stdout : 960
+Child process to stdout : 961
+Child process to stdout : 962
+Child process to stdout : 963
+Child process to stdout : 964
+Child process to stdout : 965
+Child process to stdout : 966
+Child process to stdout : 967
+Child process to stdout : 968
+Child process to stdout : 969
+Child process to stdout : 970
+Child process to stdout : 971
+Child process to stdout : 972
+Child process to stdout : 973
+Child process to stdout : 974
+Child process to stdout : 975
+Child process to stdout : 976
+Child process to stdout : 977
+Child process to stdout : 978
+Child process to stdout : 979
+Child process to stdout : 980
+Child process to stdout : 981
+Child process to stdout : 982
+Child process to stdout : 983
+Child process to stdout : 984
+Child process to stdout : 985
+Child process to stdout : 986
+Child process to stdout : 987
+Child process to stdout : 988
+Child process to stdout : 989
+Child process to stdout : 990
+Child process to stdout : 991
+Child process to stdout : 992
+Child process to stdout : 993
+Child process to stdout : 994
+Child process to stdout : 995
+Child process to stdout : 996
+Child process to stdout : 997
+Child process to stdout : 998
+Child process to stdout : 999
+Child process to stdout : 1000
+Child process to stdout : 1001
+Child process to stdout : 1002
+Child process to stdout : 1003
+Child process to stdout : 1004
+Child process to stdout : 1005
+Child process to stdout : 1006
+Child process to stdout : 1007
+Child process to stdout : 1008
+Child process to stdout : 1009
+Child process to stdout : 1010
+Child process to stdout : 1011
+Child process to stdout : 1012
+Child process to stdout : 1013
+Child process to stdout : 1014
+Child process to stdout : 1015
+Child process to stdout : 1016
+Child process to stdout : 1017
+Child process to stdout : 1018
+Child process to stdout : 1019
+Child process to stdout : 1020
+Child process to stdout : 1021
+Child process to stdout : 1022
+Child process to stdout : 1023
+Child process to stdout : 1024
+Child process to stdout : 1025
+Child process to stdout : 1026
+Child process to stdout : 1027
+Child process to stdout : 1028
+Child process to stdout : 1029
+Child process to stdout : 1030
+Child process to stdout : 1031
+Child process to stdout : 1032
+Child process to stdout : 1033
+Child process to stdout : 1034
+Child process to stdout : 1035
+Child process to stdout : 1036
+Child process to stdout : 1037
+Child process to stdout : 1038
+Child process to stdout : 1039
+Child process to stdout : 1040
+Child process to stdout : 1041
+Child process to stdout : 1042
+Child process to stdout : 1043
+Child process to stdout : 1044
+Child process to stdout : 1045
+Child process to stdout : 1046
+Child process to stdout : 1047
+Child process to stdout : 1048
+Child process to stdout : 1049
+Child process to stdout : 1050
+Child process to stdout : 1051
+Child process to stdout : 1052
+Child process to stdout : 1053
+Child process to stdout : 1054
+Child process to stdout : 1055
+Child process to stdout : 1056
+Child process to stdout : 1057
+Child process to stdout : 1058
+Child process to stdout : 1059
+Child process to stdout : 1060
+Child process to stdout : 1061
+Child process to stdout : 1062
+Child process to stdout : 1063
+Child process to stdout : 1064
+Child process to stdout : 1065
+Child process to stdout : 1066
+Child process to stdout : 1067
+Child process to stdout : 1068
+Child process to stdout : 1069
+Child process to stdout : 1070
+Child process to stdout : 1071
+Child process to stdout : 1072
+Child process to stdout : 1073
+Child process to stdout : 1074
+Child process to stdout : 1075
+Child process to stdout : 1076
+Child process to stdout : 1077
+Child process to stdout : 1078
+Child process to stdout : 1079
+Child process to stdout : 1080
+Child process to stdout : 1081
+Child process to stdout : 1082
+Child process to stdout : 1083
+Child process to stdout : 1084
+Child process to stdout : 1085
+Child process to stdout : 1086
+Child process to stdout : 1087
+Child process to stdout : 1088
+Child process to stdout : 1089
+Child process to stdout : 1090
+Child process to stdout : 1091
+Child process to stdout : 1092
+Child process to stdout : 1093
+Child process to stdout : 1094
+Child process to stdout : 1095
+Child process to stdout : 1096
+Child process to stdout : 1097
+Child process to stdout : 1098
+Child process to stdout : 1099
+Child process to stdout : 1100
+Child process to stdout : 1101
+Child process to stdout : 1102
+Child process to stdout : 1103
+Child process to stdout : 1104
+Child process to stdout : 1105
+Child process to stdout : 1106
+Child process to stdout : 1107
+Child process to stdout : 1108
+Child process to stdout : 1109
+Child process to stdout : 1110
+Child process to stdout : 1111
+Child process to stdout : 1112
+Child process to stdout : 1113
+Child process to stdout : 1114
+Child process to stdout : 1115
+Child process to stdout : 1116
+Child process to stdout : 1117
+Child process to stdout : 1118
+Child process to stdout : 1119
+Child process to stdout : 1120
+Child process to stdout : 1121
+Child process to stdout : 1122
+Child process to stdout : 1123
+Child process to stdout : 1124
+Child process to stdout : 1125
+Child process to stdout : 1126
+Child process to stdout : 1127
+Child process to stdout : 1128
+Child process to stdout : 1129
+Child process to stdout : 1130
+Child process to stdout : 1131
+Child process to stdout : 1132
+Child process to stdout : 1133
+Child process to stdout : 1134
+Child process to stdout : 1135
+Child process to stdout : 1136
+Child process to stdout : 1137
+Child process to stdout : 1138
+Child process to stdout : 1139
+Child process to stdout : 1140
+Child process to stdout : 1141
+Child process to stdout : 1142
+Child process to stdout : 1143
+Child process to stdout : 1144
+Child process to stdout : 1145
+Child process to stdout : 1146
+Child process to stdout : 1147
+Child process to stdout : 1148
+Child process to stdout : 1149
+Child process to stdout : 1150
+Child process to stdout : 1151
+Child process to stdout : 1152
+Child process to stdout : 1153
+Child process to stdout : 1154
+Child process to stdout : 1155
+Child process to stdout : 1156
+Child process to stdout : 1157
+Child process to stdout : 1158
+Child process to stdout : 1159
+Child process to stdout : 1160
+Child process to stdout : 1161
+Child process to stdout : 1162
+Child process to stdout : 1163
+Child process to stdout : 1164
+Child process to stdout : 1165
+Child process to stdout : 1166
+Child process to stdout : 1167
+Child process to stdout : 1168
+Child process to stdout : 1169
+Child process to stdout : 1170
+Child process to stdout : 1171
+Child process to stdout : 1172
+Child process to stdout : 1173
+Child process to stdout : 1174
+Child process to stdout : 1175
+Child process to stdout : 1176
+Child process to stdout : 1177
+Child process to stdout : 1178
+Child process to stdout : 1179
+Child process to stdout : 1180
+Child process to stdout : 1181
+Child process to stdout : 1182
+Child process to stdout : 1183
+Child process to stdout : 1184
+Child process to stdout : 1185
+Child process to stdout : 1186
+Child process to stdout : 1187
+Child process to stdout : 1188
+Child process to stdout : 1189
+Child process to stdout : 1190
+Child process to stdout : 1191
+Child process to stdout : 1192
+Child process to stdout : 1193
+Child process to stdout : 1194
+Child process to stdout : 1195
+Child process to stdout : 1196
+Child process to stdout : 1197
+Child process to stdout : 1198
+Child process to stdout : 1199
+Child process to stdout : 1200
+Child process to stdout : 1201
+Child process to stdout : 1202
+Child process to stdout : 1203
+Child process to stdout : 1204
+Child process to stdout : 1205
+Child process to stdout : 1206
+Child process to stdout : 1207
+Child process to stdout : 1208
+Child process to stdout : 1209
+Child process to stdout : 1210
+Child process to stdout : 1211
+Child process to stdout : 1212
+Child process to stdout : 1213
+Child process to stdout : 1214
+Child process to stdout : 1215
+Child process to stdout : 1216
+Child process to stdout : 1217
+Child process to stdout : 1218
+Child process to stdout : 1219
+Child process to stdout : 1220
+Child process to stdout : 1221
+Child process to stdout : 1222
+Child process to stdout : 1223
+Child process to stdout : 1224
+Child process to stdout : 1225
+Child process to stdout : 1226
+Child process to stdout : 1227
+Child process to stdout : 1228
+Child process to stdout : 1229
+Child process to stdout : 1230
+Child process to stdout : 1231
+Child process to stdout : 1232
+Child process to stdout : 1233
+Child process to stdout : 1234
+Child process to stdout : 1235
+Child process to stdout : 1236
+Child process to stdout : 1237
+Child process to stdout : 1238
+Child process to stdout : 1239
+Child process to stdout : 1240
+Child process to stdout : 1241
+Child process to stdout : 1242
+Child process to stdout : 1243
+Child process to stdout : 1244
+Child process to stdout : 1245
+Child process to stdout : 1246
+Child process to stdout : 1247
+Child process to stdout : 1248
+Child process to stdout : 1249
+Child process to stdout : 1250
+Child process to stdout : 1251
+Child process to stdout : 1252
+Child process to stdout : 1253
+Child process to stdout : 1254
+Child process to stdout : 1255
+Child process to stdout : 1256
+Child process to stdout : 1257
+Child process to stdout : 1258
+Child process to stdout : 1259
+Child process to stdout : 1260
+Child process to stdout : 1261
+Child process to stdout : 1262
+Child process to stdout : 1263
+Child process to stdout : 1264
+Child process to stdout : 1265
+Child process to stdout : 1266
+Child process to stdout : 1267
+Child process to stdout : 1268
+Child process to stdout : 1269
+Child process to stdout : 1270
+Child process to stdout : 1271
+Child process to stdout : 1272
+Child process to stdout : 1273
+Child process to stdout : 1274
+Child process to stdout : 1275
+Child process to stdout : 1276
+Child process to stdout : 1277
+Child process to stdout : 1278
+Child process to stdout : 1279
+Child process to stdout : 1280
+Child process to stdout : 1281
+Child process to stdout : 1282
+Child process to stdout : 1283
+Child process to stdout : 1284
+Child process to stdout : 1285
+Child process to stdout : 1286
+Child process to stdout : 1287
+Child process to stdout : 1288
+Child process to stdout : 1289
+Child process to stdout : 1290
+Child process to stdout : 1291
+Child process to stdout : 1292
+Child process to stdout : 1293
+Child process to stdout : 1294
+Child process to stdout : 1295
+Child process to stdout : 1296
+Child process to stdout : 1297
+Child process to stdout : 1298
+Child process to stdout : 1299
+Child process to stdout : 1300
+Child process to stdout : 1301
+Child process to stdout : 1302
+Child process to stdout : 1303
+Child process to stdout : 1304
+Child process to stdout : 1305
+Child process to stdout : 1306
+Child process to stdout : 1307
+Child process to stdout : 1308
+Child process to stdout : 1309
+Child process to stdout : 1310
+Child process to stdout : 1311
+Child process to stdout : 1312
+Child process to stdout : 1313
+Child process to stdout : 1314
+Child process to stdout : 1315
+Child process to stdout : 1316
+Child process to stdout : 1317
+Child process to stdout : 1318
+Child process to stdout : 1319
+Child process to stdout : 1320
+Child process to stdout : 1321
+Child process to stdout : 1322
+Child process to stdout : 1323
+Child process to stdout : 1324
+Child process to stdout : 1325
+Child process to stdout : 1326
+Child process to stdout : 1327
+Child process to stdout : 1328
+Child process to stdout : 1329
+Child process to stdout : 1330
+Child process to stdout : 1331
+Child process to stdout : 1332
+Child process to stdout : 1333
+Child process to stdout : 1334
+Child process to stdout : 1335
+Child process to stdout : 1336
+Child process to stdout : 1337
+Child process to stdout : 1338
+Child process to stdout : 1339
+Child process to stdout : 1340
+Child process to stdout : 1341
+Child process to stdout : 1342
+Child process to stdout : 1343
+Child process to stdout : 1344
+Child process to stdout : 1345
+Child process to stdout : 1346
+Child process to stdout : 1347
+Child process to stdout : 1348
+Child process to stdout : 1349
+Child process to stdout : 1350
+Child process to stdout : 1351
+Child process to stdout : 1352
+Child process to stdout : 1353
+Child process to stdout : 1354
+Child process to stdout : 1355
+Child process to stdout : 1356
+Child process to stdout : 1357
+Child process to stdout : 1358
+Child process to stdout : 1359
+Child process to stdout : 1360
+Child process to stdout : 1361
+Child process to stdout : 1362
+Child process to stdout : 1363
+Child process to stdout : 1364
+Child process to stdout : 1365
+Child process to stdout : 1366
+Child process to stdout : 1367
+Child process to stdout : 1368
+Child process to stdout : 1369
+Child process to stdout : 1370
+Child process to stdout : 1371
+Child process to stdout : 1372
+Child process to stdout : 1373
+Child process to stdout : 1374
+Child process to stdout : 1375
+Child process to stdout : 1376
+Child process to stdout : 1377
+Child process to stdout : 1378
+Child process to stdout : 1379
+Child process to stdout : 1380
+Child process to stdout : 1381
+Child process to stdout : 1382
+Child process to stdout : 1383
+Child process to stdout : 1384
+Child process to stdout : 1385
+Child process to stdout : 1386
+Child process to stdout : 1387
+Child process to stdout : 1388
+Child process to stdout : 1389
+Child process to stdout : 1390
+Child process to stdout : 1391
+Child process to stdout : 1392
+Child process to stdout : 1393
+Child process to stdout : 1394
+Child process to stdout : 1395
+Child process to stdout : 1396
+Child process to stdout : 1397
+Child process to stdout : 1398
+Child process to stdout : 1399
+Child process to stdout : 1400
+Child process to stdout : 1401
+Child process to stdout : 1402
+Child process to stdout : 1403
+Child process to stdout : 1404
+Child process to stdout : 1405
+Child process to stdout : 1406
+Child process to stdout : 1407
+Child process to stdout : 1408
+Child process to stdout : 1409
+Child process to stdout : 1410
+Child process to stdout : 1411
+Child process to stdout : 1412
+Child process to stdout : 1413
+Child process to stdout : 1414
+Child process to stdout : 1415
+Child process to stdout : 1416
+Child process to stdout : 1417
+Child process to stdout : 1418
+Child process to stdout : 1419
+Child process to stdout : 1420
+Child process to stdout : 1421
+Child process to stdout : 1422
+Child process to stdout : 1423
+Child process to stdout : 1424
+Child process to stdout : 1425
+Child process to stdout : 1426
+Child process to stdout : 1427
+Child process to stdout : 1428
+Child process to stdout : 1429
+Child process to stdout : 1430
+Child process to stdout : 1431
+Child process to stdout : 1432
+Child process to stdout : 1433
+Child process to stdout : 1434
+Child process to stdout : 1435
+Child process to stdout : 1436
+Child process to stdout : 1437
+Child process to stdout : 1438
+Child process to stdout : 1439
+Child process to stdout : 1440
+Child process to stdout : 1441
+Child process to stdout : 1442
+Child process to stdout : 1443
+Child process to stdout : 1444
+Child process to stdout : 1445
+Child process to stdout : 1446
+Child process to stdout : 1447
+Child process to stdout : 1448
+Child process to stdout : 1449
+Child process to stdout : 1450
+Child process to stdout : 1451
+Child process to stdout : 1452
+Child process to stdout : 1453
+Child process to stdout : 1454
+Child process to stdout : 1455
+Child process to stdout : 1456
+Child process to stdout : 1457
+Child process to stdout : 1458
+Child process to stdout : 1459
+Child process to stdout : 1460
+Child process to stdout : 1461
+Child process to stdout : 1462
+Child process to stdout : 1463
+Child process to stdout : 1464
+Child process to stdout : 1465
+Child process to stdout : 1466
+Child process to stdout : 1467
+Child process to stdout : 1468
+Child process to stdout : 1469
+Child process to stdout : 1470
+Child process to stdout : 1471
+Child process to stdout : 1472
+Child process to stdout : 1473
+Child process to stdout : 1474
+Child process to stdout : 1475
+Child process to stdout : 1476
+Child process to stdout : 1477
+Child process to stdout : 1478
+Child process to stdout : 1479
+Child process to stdout : 1480
+Child process to stdout : 1481
+Child process to stdout : 1482
+Child process to stdout : 1483
+Child process to stdout : 1484
+Child process to stdout : 1485
+Child process to stdout : 1486
+Child process to stdout : 1487
+Child process to stdout : 1488
+Child process to stdout : 1489
+Child process to stdout : 1490
+Child process to stdout : 1491
+Child process to stdout : 1492
+Child process to stdout : 1493
+Child process to stdout : 1494
+Child process to stdout : 1495
+Child process to stdout : 1496
+Child process to stdout : 1497
+Child process to stdout : 1498
+Child process to stdout : 1499
+Child process to stdout : 1500
+Child process to stdout : 1501
+Child process to stdout : 1502
+Child process to stdout : 1503
+Child process to stdout : 1504
+Child process to stdout : 1505
+Child process to stdout : 1506
+Child process to stdout : 1507
+Child process to stdout : 1508
+Child process to stdout : 1509
+Child process to stdout : 1510
+Child process to stdout : 1511
+Child process to stdout : 1512
+Child process to stdout : 1513
+Child process to stdout : 1514
+Child process to stdout : 1515
+Child process to stdout : 1516
+Child process to stdout : 1517
+Child process to stdout : 1518
+Child process to stdout : 1519
+Child process to stdout : 1520
+Child process to stdout : 1521
+Child process to stdout : 1522
+Child process to stdout : 1523
+Child process to stdout : 1524
+Child process to stdout : 1525
+Child process to stdout : 1526
+Child process to stdout : 1527
+Child process to stdout : 1528
+Child process to stdout : 1529
+Child process to stdout : 1530
+Child process to stdout : 1531
+Child process to stdout : 1532
+Child process to stdout : 1533
+Child process to stdout : 1534
+Child process to stdout : 1535
+Child process to stdout : 1536
+Child process to stdout : 1537
+Child process to stdout : 1538
+Child process to stdout : 1539
+Child process to stdout : 1540
+Child process to stdout : 1541
+Child process to stdout : 1542
+Child process to stdout : 1543
+Child process to stdout : 1544
+Child process to stdout : 1545
+Child process to stdout : 1546
+Child process to stdout : 1547
+Child process to stdout : 1548
+Child process to stdout : 1549
+Child process to stdout : 1550
+Child process to stdout : 1551
+Child process to stdout : 1552
+Child process to stdout : 1553
+Child process to stdout : 1554
+Child process to stdout : 1555
+Child process to stdout : 1556
+Child process to stdout : 1557
+Child process to stdout : 1558
+Child process to stdout : 1559
+Child process to stdout : 1560
+Child process to stdout : 1561
+Child process to stdout : 1562
+Child process to stdout : 1563
+Child process to stdout : 1564
+Child process to stdout : 1565
+Child process to stdout : 1566
+Child process to stdout : 1567
+Child process to stdout : 1568
+Child process to stdout : 1569
+Child process to stdout : 1570
+Child process to stdout : 1571
+Child process to stdout : 1572
+Child process to stdout : 1573
+Child process to stdout : 1574
+Child process to stdout : 1575
+Child process to stdout : 1576
+Child process to stdout : 1577
+Child process to stdout : 1578
+Child process to stdout : 1579
+Child process to stdout : 1580
+Child process to stdout : 1581
+Child process to stdout : 1582
+Child process to stdout : 1583
+Child process to stdout : 1584
+Child process to stdout : 1585
+Child process to stdout : 1586
+Child process to stdout : 1587
+Child process to stdout : 1588
+Child process to stdout : 1589
+Child process to stdout : 1590
+Child process to stdout : 1591
+Child process to stdout : 1592
+Child process to stdout : 1593
+Child process to stdout : 1594
+Child process to stdout : 1595
+Child process to stdout : 1596
+Child process to stdout : 1597
+Child process to stdout : 1598
+Child process to stdout : 1599
+Child process to stdout : 1600
+Child process to stdout : 1601
+Child process to stdout : 1602
+Child process to stdout : 1603
+Child process to stdout : 1604
+Child process to stdout : 1605
+Child process to stdout : 1606
+Child process to stdout : 1607
+Child process to stdout : 1608
+Child process to stdout : 1609
+Child process to stdout : 1610
+Child process to stdout : 1611
+Child process to stdout : 1612
+Child process to stdout : 1613
+Child process to stdout : 1614
+Child process to stdout : 1615
+Child process to stdout : 1616
+Child process to stdout : 1617
+Child process to stdout : 1618
+Child process to stdout : 1619
+Child process to stdout : 1620
+Child process to stdout : 1621
+Child process to stdout : 1622
+Child process to stdout : 1623
+Child process to stdout : 1624
+Child process to stdout : 1625
+Child process to stdout : 1626
+Child process to stdout : 1627
+Child process to stdout : 1628
+Child process to stdout : 1629
+Child process to stdout : 1630
+Child process to stdout : 1631
+Child process to stdout : 1632
+Child process to stdout : 1633
+Child process to stdout : 1634
+Child process to stdout : 1635
+Child process to stdout : 1636
+Child process to stdout : 1637
+Child process to stdout : 1638
+Child process to stdout : 1639
+Child process to stdout : 1640
+Child process to stdout : 1641
+Child process to stdout : 1642
+Child process to stdout : 1643
+Child process to stdout : 1644
+Child process to stdout : 1645
+Child process to stdout : 1646
+Child process to stdout : 1647
+Child process to stdout : 1648
+Child process to stdout : 1649
+Child process to stdout : 1650
+Child process to stdout : 1651
+Child process to stdout : 1652
+Child process to stdout : 1653
+Child process to stdout : 1654
+Child process to stdout : 1655
+Child process to stdout : 1656
+Child process to stdout : 1657
+Child process to stdout : 1658
+Child process to stdout : 1659
+Child process to stdout : 1660
+Child process to stdout : 1661
+Child process to stdout : 1662
+Child process to stdout : 1663
+Child process to stdout : 1664
+Child process to stdout : 1665
+Child process to stdout : 1666
+Child process to stdout : 1667
+Child process to stdout : 1668
+Child process to stdout : 1669
+Child process to stdout : 1670
+Child process to stdout : 1671
+Child process to stdout : 1672
+Child process to stdout : 1673
+Child process to stdout : 1674
+Child process to stdout : 1675
+Child process to stdout : 1676
+Child process to stdout : 1677
+Child process to stdout : 1678
+Child process to stdout : 1679
+Child process to stdout : 1680
+Child process to stdout : 1681
+Child process to stdout : 1682
+Child process to stdout : 1683
+Child process to stdout : 1684
+Child process to stdout : 1685
+Child process to stdout : 1686
+Child process to stdout : 1687
+Child process to stdout : 1688
+Child process to stdout : 1689
+Child process to stdout : 1690
+Child process to stdout : 1691
+Child process to stdout : 1692
+Child process to stdout : 1693
+Child process to stdout : 1694
+Child process to stdout : 1695
+Child process to stdout : 1696
+Child process to stdout : 1697
+Child process to stdout : 1698
+Child process to stdout : 1699
+Child process to stdout : 1700
+Child process to stdout : 1701
+Child process to stdout : 1702
+Child process to stdout : 1703
+Child process to stdout : 1704
+Child process to stdout : 1705
+Child process to stdout : 1706
+Child process to stdout : 1707
+Child process to stdout : 1708
+Child process to stdout : 1709
+Child process to stdout : 1710
+Child process to stdout : 1711
+Child process to stdout : 1712
+Child process to stdout : 1713
+Child process to stdout : 1714
+Child process to stdout : 1715
+Child process to stdout : 1716
+Child process to stdout : 1717
+Child process to stdout : 1718
+Child process to stdout : 1719
+Child process to stdout : 1720
+Child process to stdout : 1721
+Child process to stdout : 1722
+Child process to stdout : 1723
+Child process to stdout : 1724
+Child process to stdout : 1725
+Child process to stdout : 1726
+Child process to stdout : 1727
+Child process to stdout : 1728
+Child process to stdout : 1729
+Child process to stdout : 1730
+Child process to stdout : 1731
+Child process to stdout : 1732
+Child process to stdout : 1733
+Child process to stdout : 1734
+Child process to stdout : 1735
+Child process to stdout : 1736
+Child process to stdout : 1737
+Child process to stdout : 1738
+Child process to stdout : 1739
+Child process to stdout : 1740
+Child process to stdout : 1741
+Child process to stdout : 1742
+Child process to stdout : 1743
+Child process to stdout : 1744
+Child process to stdout : 1745
+Child process to stdout : 1746
+Child process to stdout : 1747
+Child process to stdout : 1748
+Child process to stdout : 1749
+Child process to stdout : 1750
+Child process to stdout : 1751
+Child process to stdout : 1752
+Child process to stdout : 1753
+Child process to stdout : 1754
+Child process to stdout : 1755
+Child process to stdout : 1756
+Child process to stdout : 1757
+Child process to stdout : 1758
+Child process to stdout : 1759
+Child process to stdout : 1760
+Child process to stdout : 1761
+Child process to stdout : 1762
+Child process to stdout : 1763
+Child process to stdout : 1764
+Child process to stdout : 1765
+Child process to stdout : 1766
+Child process to stdout : 1767
+Child process to stdout : 1768
+Child process to stdout : 1769
+Child process to stdout : 1770
+Child process to stdout : 1771
+Child process to stdout : 1772
+Child process to stdout : 1773
+Child process to stdout : 1774
+Child process to stdout : 1775
+Child process to stdout : 1776
+Child process to stdout : 1777
+Child process to stdout : 1778
+Child process to stdout : 1779
+Child process to stdout : 1780
+Child process to stdout : 1781
+Child process to stdout : 1782
+Child process to stdout : 1783
+Child process to stdout : 1784
+Child process to stdout : 1785
+Child process to stdout : 1786
+Child process to stdout : 1787
+Child process to stdout : 1788
+Child process to stdout : 1789
+Child process to stdout : 1790
+Child process to stdout : 1791
+Child process to stdout : 1792
+Child process to stdout : 1793
+Child process to stdout : 1794
+Child process to stdout : 1795
+Child process to stdout : 1796
+Child process to stdout : 1797
+Child process to stdout : 1798
+Child process to stdout : 1799
+Child process to stdout : 1800
+Child process to stdout : 1801
+Child process to stdout : 1802
+Child process to stdout : 1803
+Child process to stdout : 1804
+Child process to stdout : 1805
+Child process to stdout : 1806
+Child process to stdout : 1807
+Child process to stdout : 1808
+Child process to stdout : 1809
+Child process to stdout : 1810
+Child process to stdout : 1811
+Child process to stdout : 1812
+Child process to stdout : 1813
+Child process to stdout : 1814
+Child process to stdout : 1815
+Child process to stdout : 1816
+Child process to stdout : 1817
+Child process to stdout : 1818
+Child process to stdout : 1819
+Child process to stdout : 1820
+Child process to stdout : 1821
+Child process to stdout : 1822
+Child process to stdout : 1823
+Child process to stdout : 1824
+Child process to stdout : 1825
+Child process to stdout : 1826
+Child process to stdout : 1827
+Child process to stdout : 1828
+Child process to stdout : 1829
+Child process to stdout : 1830
+Child process to stdout : 1831
+Child process to stdout : 1832
+Child process to stdout : 1833
+Child process to stdout : 1834
+Child process to stdout : 1835
+Child process to stdout : 1836
+Child process to stdout : 1837
+Child process to stdout : 1838
+Child process to stdout : 1839
+Child process to stdout : 1840
+Child process to stdout : 1841
+Child process to stdout : 1842
+Child process to stdout : 1843
+Child process to stdout : 1844
+Child process to stdout : 1845
+Child process to stdout : 1846
+Child process to stdout : 1847
+Child process to stdout : 1848
+Child process to stdout : 1849
+Child process to stdout : 1850
+Child process to stdout : 1851
+Child process to stdout : 1852
+Child process to stdout : 1853
+Child process to stdout : 1854
+Child process to stdout : 1855
+Child process to stdout : 1856
+Child process to stdout : 1857
+Child process to stdout : 1858
+Child process to stdout : 1859
+Child process to stdout : 1860
+Child process to stdout : 1861
+Child process to stdout : 1862
+Child process to stdout : 1863
+Child process to stdout : 1864
+Child process to stdout : 1865
+Child process to stdout : 1866
+Child process to stdout : 1867
+Child process to stdout : 1868
+Child process to stdout : 1869
+Child process to stdout : 1870
+Child process to stdout : 1871
+Child process to stdout : 1872
+Child process to stdout : 1873
+Child process to stdout : 1874
+Child process to stdout : 1875
+Child process to stdout : 1876
+Child process to stdout : 1877
+Child process to stdout : 1878
+Child process to stdout : 1879
+Child process to stdout : 1880
+Child process to stdout : 1881
+Child process to stdout : 1882
+Child process to stdout : 1883
+Child process to stdout : 1884
+Child process to stdout : 1885
+Child process to stdout : 1886
+Child process to stdout : 1887
+Child process to stdout : 1888
+Child process to stdout : 1889
+Child process to stdout : 1890
+Child process to stdout : 1891
+Child process to stdout : 1892
+Child process to stdout : 1893
+Child process to stdout : 1894
+Child process to stdout : 1895
+Child process to stdout : 1896
+Child process to stdout : 1897
+Child process to stdout : 1898
+Child process to stdout : 1899
+Child process to stdout : 1900
+Child process to stdout : 1901
+Child process to stdout : 1902
+Child process to stdout : 1903
+Child process to stdout : 1904
+Child process to stdout : 1905
+Child process to stdout : 1906
+Child process to stdout : 1907
+Child process to stdout : 1908
+Child process to stdout : 1909
+Child process to stdout : 1910
+Child process to stdout : 1911
+Child process to stdout : 1912
+Child process to stdout : 1913
+Child process to stdout : 1914
+Child process to stdout : 1915
+Child process to stdout : 1916
+Child process to stdout : 1917
+Child process to stdout : 1918
+Child process to stdout : 1919
+Child process to stdout : 1920
+Child process to stdout : 1921
+Child process to stdout : 1922
+Child process to stdout : 1923
+Child process to stdout : 1924
+Child process to stdout : 1925
+Child process to stdout : 1926
+Child process to stdout : 1927
+Child process to stdout : 1928
+Child process to stdout : 1929
+Child process to stdout : 1930
+Child process to stdout : 1931
+Child process to stdout : 1932
+Child process to stdout : 1933
+Child process to stdout : 1934
+Child process to stdout : 1935
+Child process to stdout : 1936
+Child process to stdout : 1937
+Child process to stdout : 1938
+Child process to stdout : 1939
+Child process to stdout : 1940
+Child process to stdout : 1941
+Child process to stdout : 1942
+Child process to stdout : 1943
+Child process to stdout : 1944
+Child process to stdout : 1945
+Child process to stdout : 1946
+Child process to stdout : 1947
+Child process to stdout : 1948
+Child process to stdout : 1949
+Child process to stdout : 1950
+Child process to stdout : 1951
+Child process to stdout : 1952
+Child process to stdout : 1953
+Child process to stdout : 1954
+Child process to stdout : 1955
+Child process to stdout : 1956
+Child process to stdout : 1957
+Child process to stdout : 1958
+Child process to stdout : 1959
+Child process to stdout : 1960
+Child process to stdout : 1961
+Child process to stdout : 1962
+Child process to stdout : 1963
+Child process to stdout : 1964
+Child process to stdout : 1965
+Child process to stdout : 1966
+Child process to stdout : 1967
+Child process to stdout : 1968
+Child process to stdout : 1969
+Child process to stdout : 1970
+Child process to stdout : 1971
+Child process to stdout : 1972
+Child process to stdout : 1973
+Child process to stdout : 1974
+Child process to stdout : 1975
+Child process to stdout : 1976
+Child process to stdout : 1977
+Child process to stdout : 1978
+Child process to stdout : 1979
+Child process to stdout : 1980
+Child process to stdout : 1981
+Child process to stdout : 1982
+Child process to stdout : 1983
+Child process to stdout : 1984
+Child process to stdout : 1985
+Child process to stdout : 1986
+Child process to stdout : 1987
+Child process to stdout : 1988
+Child process to stdout : 1989
+Child process to stdout : 1990
+Child process to stdout : 1991
+Child process to stdout : 1992
+Child process to stdout : 1993
+Child process to stdout : 1994
+Child process to stdout : 1995
+Child process to stdout : 1996
+Child process to stdout : 1997
+Child process to stdout : 1998
+Child process to stdout : 1999
+Child process to stdout : 2000
+Child process to stdout : 2001
+Child process to stdout : 2002
+Child process to stdout : 2003
+Child process to stdout : 2004
+Child process to stdout : 2005
+Child process to stdout : 2006
+Child process to stdout : 2007
+Child process to stdout : 2008
+Child process to stdout : 2009
+Child process to stdout : 2010
+Child process to stdout : 2011
+Child process to stdout : 2012
+Child process to stdout : 2013
+Child process to stdout : 2014
+Child process to stdout : 2015
+Child process to stdout : 2016
+Child process to stdout : 2017
+Child process to stdout : 2018
+Child process to stdout : 2019
+Child process to stdout : 2020
+Child process to stdout : 2021
+Child process to stdout : 2022
+Child process to stdout : 2023
+Child process to stdout : 2024
+Child process to stdout : 2025
+Child process to stdout : 2026
+Child process to stdout : 2027
+Child process to stdout : 2028
+Child process to stdout : 2029
+Child process to stdout : 2030
+Child process to stdout : 2031
+Child process to stdout : 2032
+Child process to stdout : 2033
+Child process to stdout : 2034
+Child process to stdout : 2035
+Child process to stdout : 2036
+Child process to stdout : 2037
+Child process to stdout : 2038
+Child process to stdout : 2039
+Child process to stdout : 2040
+Child process to stdout : 2041
+Child process to stdout : 2042
+Child process to stdout : 2043
+Child process to stdout : 2044
+Child process to stdout : 2045
+Child process to stdout : 2046
+Child process to stdout : 2047
+Child process to stdout : 2048
+Child process to stdout : 2049
+Child process to stdout : 2050
+Child process to stdout : 2051
+Child process to stdout : 2052
+Child process to stdout : 2053
+Child process to stdout : 2054
+Child process to stdout : 2055
+Child process to stdout : 2056
+Child process to stdout : 2057
+Child process to stdout : 2058
+Child process to stdout : 2059
+Child process to stdout : 2060
+Child process to stdout : 2061
+Child process to stdout : 2062
+Child process to stdout : 2063
+Child process to stdout : 2064
+Child process to stdout : 2065
+Child process to stdout : 2066
+Child process to stdout : 2067
+Child process to stdout : 2068
+Child process to stdout : 2069
+Child process to stdout : 2070
+Child process to stdout : 2071
+Child process to stdout : 2072
+Child process to stdout : 2073
+Child process to stdout : 2074
+Child process to stdout : 2075
+Child process to stdout : 2076
+Child process to stdout : 2077
+Child process to stdout : 2078
+Child process to stdout : 2079
+Child process to stdout : 2080
+Child process to stdout : 2081
+Child process to stdout : 2082
+Child process to stdout : 2083
+Child process to stdout : 2084
+Child process to stdout : 2085
+Child process to stdout : 2086
+Child process to stdout : 2087
+Child process to stdout : 2088
+Child process to stdout : 2089
+Child process to stdout : 2090
+Child process to stdout : 2091
+Child process to stdout : 2092
+Child process to stdout : 2093
+Child process to stdout : 2094
+Child process to stdout : 2095
+Child process to stdout : 2096
+Child process to stdout : 2097
+Child process to stdout : 2098
+Child process to stdout : 2099
+Child process to stdout : 2100
+Child process to stdout : 2101
+Child process to stdout : 2102
+Child process to stdout : 2103
+Child process to stdout : 2104
+Child process to stdout : 2105
+Child process to stdout : 2106
+Child process to stdout : 2107
+Child process to stdout : 2108
+Child process to stdout : 2109
+Child process to stdout : 2110
+Child process to stdout : 2111
+Child process to stdout : 2112
+Child process to stdout : 2113
+Child process to stdout : 2114
+Child process to stdout : 2115
+Child process to stdout : 2116
+Child process to stdout : 2117
+Child process to stdout : 2118
+Child process to stdout : 2119
+Child process to stdout : 2120
+Child process to stdout : 2121
+Child process to stdout : 2122
+Child process to stdout : 2123
+Child process to stdout : 2124
+Child process to stdout : 2125
+Child process to stdout : 2126
+Child process to stdout : 2127
+Child process to stdout : 2128
+Child process to stdout : 2129
+Child process to stdout : 2130
+Child process to stdout : 2131
+Child process to stdout : 2132
+Child process to stdout : 2133
+Child process to stdout : 2134
+Child process to stdout : 2135
+Child process to stdout : 2136
+Child process to stdout : 2137
+Child process to stdout : 2138
+Child process to stdout : 2139
+Child process to stdout : 2140
+Child process to stdout : 2141
+Child process to stdout : 2142
+Child process to stdout : 2143
+Child process to stdout : 2144
+Child process to stdout : 2145
+Child process to stdout : 2146
+Child process to stdout : 2147
+Child process to stdout : 2148
+Child process to stdout : 2149
+Child process to stdout : 2150
+Child process to stdout : 2151
+Child process to stdout : 2152
+Child process to stdout : 2153
+Child process to stdout : 2154
+Child process to stdout : 2155
+Child process to stdout : 2156
+Child process to stdout : 2157
+Child process to stdout : 2158
+Child process to stdout : 2159
+Child process to stdout : 2160
+Child process to stdout : 2161
+Child process to stdout : 2162
+Child process to stdout : 2163
+Child process to stdout : 2164
+Child process to stdout : 2165
+Child process to stdout : 2166
+Child process to stdout : 2167
+Child process to stdout : 2168
+Child process to stdout : 2169
+Child process to stdout : 2170
+Child process to stdout : 2171
+Child process to stdout : 2172
+Child process to stdout : 2173
+Child process to stdout : 2174
+Child process to stdout : 2175
+Child process to stdout : 2176
+Child process to stdout : 2177
+Child process to stdout : 2178
+Child process to stdout : 2179
+Child process to stdout : 2180
+Child process to stdout : 2181
+Child process to stdout : 2182
+Child process to stdout : 2183
+Child process to stdout : 2184
+Child process to stdout : 2185
+Child process to stdout : 2186
+Child process to stdout : 2187
+Child process to stdout : 2188
+Child process to stdout : 2189
+Child process to stdout : 2190
+Child process to stdout : 2191
+Child process to stdout : 2192
+Child process to stdout : 2193
+Child process to stdout : 2194
+Child process to stdout : 2195
+Child process to stdout : 2196
+Child process to stdout : 2197
+Child process to stdout : 2198
+Child process to stdout : 2199
+Child process to stdout : 2200
+Child process to stdout : 2201
+Child process to stdout : 2202
+Child process to stdout : 2203
+Child process to stdout : 2204
+Child process to stdout : 2205
+Child process to stdout : 2206
+Child process to stdout : 2207
+Child process to stdout : 2208
+Child process to stdout : 2209
+Child process to stdout : 2210
+Child process to stdout : 2211
+Child process to stdout : 2212
+Child process to stdout : 2213
+Child process to stdout : 2214
+Child process to stdout : 2215
+Child process to stdout : 2216
+Child process to stdout : 2217
+Child process to stdout : 2218
+Child process to stdout : 2219
+Child process to stdout : 2220
+Child process to stdout : 2221
+Child process to stdout : 2222
+Child process to stdout : 2223
+Child process to stdout : 2224
+Child process to stdout : 2225
+Child process to stdout : 2226
+Child process to stdout : 2227
+Child process to stdout : 2228
+Child process to stdout : 2229
+Child process to stdout : 2230
+Child process to stdout : 2231
+Child process to stdout : 2232
+Child process to stdout : 2233
+Child process to stdout : 2234
+Child process to stdout : 2235
+Child process to stdout : 2236
+Child process to stdout : 2237
+Child process to stdout : 2238
+Child process to stdout : 2239
+Child process to stdout : 2240
+Child process to stdout : 2241
+Child process to stdout : 2242
+Child process to stdout : 2243
+Child process to stdout : 2244
+Child process to stdout : 2245
+Child process to stdout : 2246
+Child process to stdout : 2247
+Child process to stdout : 2248
+Child process to stdout : 2249
+Child process to stdout : 2250
+Child process to stdout : 2251
+Child process to stdout : 2252
+Child process to stdout : 2253
+Child process to stdout : 2254
+Child process to stdout : 2255
+Child process to stdout : 2256
+Child process to stdout : 2257
+Child process to stdout : 2258
+Child process to stdout : 2259
+Child process to stdout : 2260
+Child process to stdout : 2261
+Child process to stdout : 2262
+Child process to stdout : 2263
+Child process to stdout : 2264
+Child process to stdout : 2265
+Child process to stdout : 2266
+Child process to stdout : 2267
+Child process to stdout : 2268
+Child process to stdout : 2269
+Child process to stdout : 2270
+Child process to stdout : 2271
+Child process to stdout : 2272
+Child process to stdout : 2273
+Child process to stdout : 2274
+Child process to stdout : 2275
+Child process to stdout : 2276
+Child process to stdout : 2277
+Child process to stdout : 2278
+Child process to stdout : 2279
+Child process to stdout : 2280
+Child process to stdout : 2281
+Child process to stdout : 2282
+Child process to stdout : 2283
+Child process to stdout : 2284
+Child process to stdout : 2285
+Child process to stdout : 2286
+Child process to stdout : 2287
+Child process to stdout : 2288
+Child process to stdout : 2289
+Child process to stdout : 2290
+Child process to stdout : 2291
+Child process to stdout : 2292
+Child process to stdout : 2293
+Child process to stdout : 2294
+Child process to stdout : 2295
+Child process to stdout : 2296
+Child process to stdout : 2297
+Child process to stdout : 2298
+Child process to stdout : 2299
+Child process to stdout : 2300
+Child process to stdout : 2301
+Child process to stdout : 2302
+Child process to stdout : 2303
+Child process to stdout : 2304
+Child process to stdout : 2305
+Child process to stdout : 2306
+Child process to stdout : 2307
+Child process to stdout : 2308
+Child process to stdout : 2309
+Child process to stdout : 2310
+Child process to stdout : 2311
+Child process to stdout : 2312
+Child process to stdout : 2313
+Child process to stdout : 2314
+Child process to stdout : 2315
+Child process to stdout : 2316
+Child process to stdout : 2317
+Child process to stdout : 2318
+Child process to stdout : 2319
+Child process to stdout : 2320
+Child process to stdout : 2321
+Child process to stdout : 2322
+Child process to stdout : 2323
+Child process to stdout : 2324
+Child process to stdout : 2325
+Child process to stdout : 2326
+Child process to stdout : 2327
+Child process to stdout : 2328
+Child process to stdout : 2329
+Child process to stdout : 2330
+Child process to stdout : 2331
+Child process to stdout : 2332
+Child process to stdout : 2333
+Child process to stdout : 2334
+Child process to stdout : 2335
+Child process to stdout : 2336
+Child process to stdout : 2337
+Child process to stdout : 2338
+Child process to stdout : 2339
+Child process to stdout : 2340
+Child process to stdout : 2341
+Child process to stdout : 2342
+Child process to stdout : 2343
+Child process to stdout : 2344
+Child process to stdout : 2345
+Child process to stdout : 2346
+Child process to stdout : 2347
+Child process to stdout : 2348
+Child process to stdout : 2349
+Child process to stdout : 2350
+Child process to stdout : 2351
+Child process to stdout : 2352
+Child process to stdout : 2353
+Child process to stdout : 2354
+Child process to stdout : 2355
+Child process to stdout : 2356
+Child process to stdout : 2357
+Child process to stdout : 2358
+Child process to stdout : 2359
+Child process to stdout : 2360
+Child process to stdout : 2361
+Child process to stdout : 2362
+Child process to stdout : 2363
+Child process to stdout : 2364
+Child process to stdout : 2365
+Child process to stdout : 2366
+Child process to stdout : 2367
+Child process to stdout : 2368
+Child process to stdout : 2369
+Child process to stdout : 2370
+Child process to stdout : 2371
+Child process to stdout : 2372
+Child process to stdout : 2373
+Child process to stdout : 2374
+Child process to stdout : 2375
+Child process to stdout : 2376
+Child process to stdout : 2377
+Child process to stdout : 2378
+Child process to stdout : 2379
+Child process to stdout : 2380
+Child process to stdout : 2381
+Child process to stdout : 2382
+Child process to stdout : 2383
+Child process to stdout : 2384
+Child process to stdout : 2385
+Child process to stdout : 2386
+Child process to stdout : 2387
+Child process to stdout : 2388
+Child process to stdout : 2389
+Child process to stdout : 2390
+Child process to stdout : 2391
+Child process to stdout : 2392
+Child process to stdout : 2393
+Child process to stdout : 2394
+Child process to stdout : 2395
+Child process to stdout : 2396
+Child process to stdout : 2397
+Child process to stdout : 2398
+Child process to stdout : 2399
+Child process to stdout : 2400
+Child process to stdout : 2401
+Child process to stdout : 2402
+Child process to stdout : 2403
+Child process to stdout : 2404
+Child process to stdout : 2405
+Child process to stdout : 2406
+Child process to stdout : 2407
+Child process to stdout : 2408
+Child process to stdout : 2409
+Child process to stdout : 2410
+Child process to stdout : 2411
+Child process to stdout : 2412
+Child process to stdout : 2413
+Child process to stdout : 2414
+Child process to stdout : 2415
+Child process to stdout : 2416
+Child process to stdout : 2417
+Child process to stdout : 2418
+Child process to stdout : 2419
+Child process to stdout : 2420
+Child process to stdout : 2421
+Child process to stdout : 2422
+Child process to stdout : 2423
+Child process to stdout : 2424
+Child process to stdout : 2425
+Child process to stdout : 2426
+Child process to stdout : 2427
+Child process to stdout : 2428
+Child process to stdout : 2429
+Child process to stdout : 2430
+Child process to stdout : 2431
+Child process to stdout : 2432
+Child process to stdout : 2433
+Child process to stdout : 2434
+Child process to stdout : 2435
+Child process to stdout : 2436
+Child process to stdout : 2437
+Child process to stdout : 2438
+Child process to stdout : 2439
+Child process to stdout : 2440
+Child process to stdout : 2441
+Child process to stdout : 2442
+Child process to stdout : 2443
+Child process to stdout : 2444
+Child process to stdout : 2445
+Child process to stdout : 2446
+Child process to stdout : 2447
+Child process to stdout : 2448
+Child process to stdout : 2449
+Child process to stdout : 2450
+Child process to stdout : 2451
+Child process to stdout : 2452
+Child process to stdout : 2453
+Child process to stdout : 2454
+Child process to stdout : 2455
+Child process to stdout : 2456
+Child process to stdout : 2457
+Child process to stdout : 2458
+Child process to stdout : 2459
+Child process to stdout : 2460
+Child process to stdout : 2461
+Child process to stdout : 2462
+Child process to stdout : 2463
+Child process to stdout : 2464
+Child process to stdout : 2465
+Child process to stdout : 2466
+Child process to stdout : 2467
+Child process to stdout : 2468
+Child process to stdout : 2469
+Child process to stdout : 2470
+Child process to stdout : 2471
+Child process to stdout : 2472
+Child process to stdout : 2473
+Child process to stdout : 2474
+Child process to stdout : 2475
+Child process to stdout : 2476
+Child process to stdout : 2477
+Child process to stdout : 2478
+Child process to stdout : 2479
+Child process to stdout : 2480
+Child process to stdout : 2481
+Child process to stdout : 2482
+Child process to stdout : 2483
+Child process to stdout : 2484
+Child process to stdout : 2485
+Child process to stdout : 2486
+Child process to stdout : 2487
+Child process to stdout : 2488
+Child process to stdout : 2489
+Child process to stdout : 2490
+Child process to stdout : 2491
+Child process to stdout : 2492
+Child process to stdout : 2493
+Child process to stdout : 2494
+Child process to stdout : 2495
+Child process to stdout : 2496
+Child process to stdout : 2497
+Child process to stdout : 2498
+Child process to stdout : 2499
+Child process to stdout : 2500
+Child process to stdout : 2501
+Child process to stdout : 2502
+Child process to stdout : 2503
+Child process to stdout : 2504
+Child process to stdout : 2505
+Child process to stdout : 2506
+Child process to stdout : 2507
+Child process to stdout : 2508
+Child process to stdout : 2509
+Child process to stdout : 2510
+Child process to stdout : 2511
+Child process to stdout : 2512
+Child process to stdout : 2513
+Child process to stdout : 2514
+Child process to stdout : 2515
+Child process to stdout : 2516
+Child process to stdout : 2517
+Child process to stdout : 2518
+Child process to stdout : 2519
+Child process to stdout : 2520
+Child process to stdout : 2521
+Child process to stdout : 2522
+Child process to stdout : 2523
+Child process to stdout : 2524
+Child process to stdout : 2525
+Child process to stdout : 2526
+Child process to stdout : 2527
+Child process to stdout : 2528
+Child process to stdout : 2529
+Child process to stdout : 2530
+Child process to stdout : 2531
+Child process to stdout : 2532
+Child process to stdout : 2533
+Child process to stdout : 2534
+Child process to stdout : 2535
+Child process to stdout : 2536
+Child process to stdout : 2537
+Child process to stdout : 2538
+Child process to stdout : 2539
+Child process to stdout : 2540
+Child process to stdout : 2541
+Child process to stdout : 2542
+Child process to stdout : 2543
+Child process to stdout : 2544
+Child process to stdout : 2545
+Child process to stdout : 2546
+Child process to stdout : 2547
+Child process to stdout : 2548
+Child process to stdout : 2549
+Child process to stdout : 2550
+Child process to stdout : 2551
+Child process to stdout : 2552
+Child process to stdout : 2553
+Child process to stdout : 2554
+Child process to stdout : 2555
+Child process to stdout : 2556
+Child process to stdout : 2557
+Child process to stdout : 2558
+Child process to stdout : 2559
+Child process to stdout : 2560
+Child process to stdout : 2561
+Child process to stdout : 2562
+Child process to stdout : 2563
+Child process to stdout : 2564
+Child process to stdout : 2565
+Child process to stdout : 2566
+Child process to stdout : 2567
+Child process to stdout : 2568
+Child process to stdout : 2569
+Child process to stdout : 2570
+Child process to stdout : 2571
+Child process to stdout : 2572
+Child process to stdout : 2573
+Child process to stdout : 2574
+Child process to stdout : 2575
+Child process to stdout : 2576
+Child process to stdout : 2577
+Child process to stdout : 2578
+Child process to stdout : 2579
+Child process to stdout : 2580
+Child process to stdout : 2581
+Child process to stdout : 2582
+Child process to stdout : 2583
+Child process to stdout : 2584
+Child process to stdout : 2585
+Child process to stdout : 2586
+Child process to stdout : 2587
+Child process to stdout : 2588
+Child process to stdout : 2589
+Child process to stdout : 2590
+Child process to stdout : 2591
+Child process to stdout : 2592
+Child process to stdout : 2593
+Child process to stdout : 2594
+Child process to stdout : 2595
+Child process to stdout : 2596
+Child process to stdout : 2597
+Child process to stdout : 2598
+Child process to stdout : 2599
+Child process to stdout : 2600
+Child process to stdout : 2601
+Child process to stdout : 2602
+Child process to stdout : 2603
+Child process to stdout : 2604
+Child process to stdout : 2605
+Child process to stdout : 2606
+Child process to stdout : 2607
+Child process to stdout : 2608
+Child process to stdout : 2609
+Child process to stdout : 2610
+Child process to stdout : 2611
+Child process to stdout : 2612
+Child process to stdout : 2613
+Child process to stdout : 2614
+Child process to stdout : 2615
+Child process to stdout : 2616
+Child process to stdout : 2617
+Child process to stdout : 2618
+Child process to stdout : 2619
+Child process to stdout : 2620
+Child process to stdout : 2621
+Child process to stdout : 2622
+Child process to stdout : 2623
+Child process to stdout : 2624
+Child process to stdout : 2625
+Child process to stdout : 2626
+Child process to stdout : 2627
+Child process to stdout : 2628
+Child process to stdout : 2629
+Child process to stdout : 2630
+Child process to stdout : 2631
+Child process to stdout : 2632
+Child process to stdout : 2633
+Child process to stdout : 2634
+Child process to stdout : 2635
+Child process to stdout : 2636
+Child process to stdout : 2637
+Child process to stdout : 2638
+Child process to stdout : 2639
+Child process to stdout : 2640
+Child process to stdout : 2641
+Child process to stdout : 2642
+Child process to stdout : 2643
+Child process to stdout : 2644
+Child process to stdout : 2645
+Child process to stdout : 2646
+Child process to stdout : 2647
+Child process to stdout : 2648
+Child process to stdout : 2649
+Child process to stdout : 2650
+Child process to stdout : 2651
+Child process to stdout : 2652
+Child process to stdout : 2653
+Child process to stdout : 2654
+Child process to stdout : 2655
+Child process to stdout : 2656
+Child process to stdout : 2657
+Child process to stdout : 2658
+Child process to stdout : 2659
+Child process to stdout : 2660
+Child process to stdout : 2661
+Child process to stdout : 2662
+Child process to stdout : 2663
+Child process to stdout : 2664
+Child process to stdout : 2665
+Child process to stdout : 2666
+Child process to stdout : 2667
+Child process to stdout : 2668
+Child process to stdout : 2669
+Child process to stdout : 2670
+Child process to stdout : 2671
+Child process to stdout : 2672
+Child process to stdout : 2673
+Child process to stdout : 2674
+Child process to stdout : 2675
+Child process to stdout : 2676
+Child process to stdout : 2677
+Child process to stdout : 2678
+Child process to stdout : 2679
+Child process to stdout : 2680
+Child process to stdout : 2681
+Child process to stdout : 2682
+Child process to stdout : 2683
+Child process to stdout : 2684
+Child process to stdout : 2685
+Child process to stdout : 2686
+Child process to stdout : 2687
+Child process to stdout : 2688
+Child process to stdout : 2689
+Child process to stdout : 2690
+Child process to stdout : 2691
+Child process to stdout : 2692
+Child process to stdout : 2693
+Child process to stdout : 2694
+Child process to stdout : 2695
+Child process to stdout : 2696
+Child process to stdout : 2697
+Child process to stdout : 2698
+Child process to stdout : 2699
+Child process to stdout : 2700
+Child process to stdout : 2701
+Child process to stdout : 2702
+Child process to stdout : 2703
+Child process to stdout : 2704
+Child process to stdout : 2705
+Child process to stdout : 2706
+Child process to stdout : 2707
+Child process to stdout : 2708
+Child process to stdout : 2709
+Child process to stdout : 2710
+Child process to stdout : 2711
+Child process to stdout : 2712
+Child process to stdout : 2713
+Child process to stdout : 2714
+Child process to stdout : 2715
+Child process to stdout : 2716
+Child process to stdout : 2717
+Child process to stdout : 2718
+Child process to stdout : 2719
+Child process to stdout : 2720
+Child process to stdout : 2721
+Child process to stdout : 2722
+Child process to stdout : 2723
+Child process to stdout : 2724
+Child process to stdout : 2725
+Child process to stdout : 2726
+Child process to stdout : 2727
+Child process to stdout : 2728
+Child process to stdout : 2729
+Child process to stdout : 2730
+Child process to stdout : 2731
+Child process to stdout : 2732
+Child process to stdout : 2733
+Child process to stdout : 2734
+Child process to stdout : 2735
+Child process to stdout : 2736
+Child process to stdout : 2737
+Child process to stdout : 2738
+Child process to stdout : 2739
+Child process to stdout : 2740
+Child process to stdout : 2741
+Child process to stdout : 2742
+Child process to stdout : 2743
+Child process to stdout : 2744
+Child process to stdout : 2745
+Child process to stdout : 2746
+Child process to stdout : 2747
+Child process to stdout : 2748
+Child process to stdout : 2749
+Child process to stdout : 2750
+Child process to stdout : 2751
+Child process to stdout : 2752
+Child process to stdout : 2753
+Child process to stdout : 2754
+Child process to stdout : 2755
+Child process to stdout : 2756
+Child process to stdout : 2757
+Child process to stdout : 2758
+Child process to stdout : 2759
+Child process to stdout : 2760
+Child process to stdout : 2761
+Child process to stdout : 2762
+Child process to stdout : 2763
+Child process to stdout : 2764
+Child process to stdout : 2765
+Child process to stdout : 2766
+Child process to stdout : 2767
+Child process to stdout : 2768
+Child process to stdout : 2769
+Child process to stdout : 2770
+Child process to stdout : 2771
+Child process to stdout : 2772
+Child process to stdout : 2773
+Child process to stdout : 2774
+Child process to stdout : 2775
+Child process to stdout : 2776
+Child process to stdout : 2777
+Child process to stdout : 2778
+Child process to stdout : 2779
+Child process to stdout : 2780
+Child process to stdout : 2781
+Child process to stdout : 2782
+Child process to stdout : 2783
+Child process to stdout : 2784
+Child process to stdout : 2785
+Child process to stdout : 2786
+Child process to stdout : 2787
+Child process to stdout : 2788
+Child process to stdout : 2789
+Child process to stdout : 2790
+Child process to stdout : 2791
+Child process to stdout : 2792
+Child process to stdout : 2793
+Child process to stdout : 2794
+Child process to stdout : 2795
+Child process to stdout : 2796
+Child process to stdout : 2797
+Child process to stdout : 2798
+Child process to stdout : 2799
+Child process to stdout : 2800
+Child process to stdout : 2801
+Child process to stdout : 2802
+Child process to stdout : 2803
+Child process to stdout : 2804
+Child process to stdout : 2805
+Child process to stdout : 2806
+Child process to stdout : 2807
+Child process to stdout : 2808
+Child process to stdout : 2809
+Child process to stdout : 2810
+Child process to stdout : 2811
+Child process to stdout : 2812
+Child process to stdout : 2813
+Child process to stdout : 2814
+Child process to stdout : 2815
+Child process to stdout : 2816
+Child process to stdout : 2817
+Child process to stdout : 2818
+Child process to stdout : 2819
+Child process to stdout : 2820
+Child process to stdout : 2821
+Child process to stdout : 2822
+Child process to stdout : 2823
+Child process to stdout : 2824
+Child process to stdout : 2825
+Child process to stdout : 2826
+Child process to stdout : 2827
+Child process to stdout : 2828
+Child process to stdout : 2829
+Child process to stdout : 2830
+Child process to stdout : 2831
+Child process to stdout : 2832
+Child process to stdout : 2833
+Child process to stdout : 2834
+Child process to stdout : 2835
+Child process to stdout : 2836
+Child process to stdout : 2837
+Child process to stdout : 2838
+Child process to stdout : 2839
+Child process to stdout : 2840
+Child process to stdout : 2841
+Child process to stdout : 2842
+Child process to stdout : 2843
+Child process to stdout : 2844
+Child process to stdout : 2845
+Child process to stdout : 2846
+Child process to stdout : 2847
+Child process to stdout : 2848
+Child process to stdout : 2849
+Child process to stdout : 2850
+Child process to stdout : 2851
+Child process to stdout : 2852
+Child process to stdout : 2853
+Child process to stdout : 2854
+Child process to stdout : 2855
+Child process to stdout : 2856
+Child process to stdout : 2857
+Child process to stdout : 2858
+Child process to stdout : 2859
+Child process to stdout : 2860
+Child process to stdout : 2861
+Child process to stdout : 2862
+Child process to stdout : 2863
+Child process to stdout : 2864
+Child process to stdout : 2865
+Child process to stdout : 2866
+Child process to stdout : 2867
+Child process to stdout : 2868
+Child process to stdout : 2869
+Child process to stdout : 2870
+Child process to stdout : 2871
+Child process to stdout : 2872
+Child process to stdout : 2873
+Child process to stdout : 2874
+Child process to stdout : 2875
+Child process to stdout : 2876
+Child process to stdout : 2877
+Child process to stdout : 2878
+Child process to stdout : 2879
+Child process to stdout : 2880
+Child process to stdout : 2881
+Child process to stdout : 2882
+Child process to stdout : 2883
+Child process to stdout : 2884
+Child process to stdout : 2885
+Child process to stdout : 2886
+Child process to stdout : 2887
+Child process to stdout : 2888
+Child process to stdout : 2889
+Child process to stdout : 2890
+Child process to stdout : 2891
+Child process to stdout : 2892
+Child process to stdout : 2893
+Child process to stdout : 2894
+Child process to stdout : 2895
+Child process to stdout : 2896
+Child process to stdout : 2897
+Child process to stdout : 2898
+Child process to stdout : 2899
+Child process to stdout : 2900
+Child process to stdout : 2901
+Child process to stdout : 2902
+Child process to stdout : 2903
+Child process to stdout : 2904
+Child process to stdout : 2905
+Child process to stdout : 2906
+Child process to stdout : 2907
+Child process to stdout : 2908
+Child process to stdout : 2909
+Child process to stdout : 2910
+Child process to stdout : 2911
+Child process to stdout : 2912
+Child process to stdout : 2913
+Child process to stdout : 2914
+Child process to stdout : 2915
+Child process to stdout : 2916
+Child process to stdout : 2917
+Child process to stdout : 2918
+Child process to stdout : 2919
+Child process to stdout : 2920
+Child process to stdout : 2921
+Child process to stdout : 2922
+Child process to stdout : 2923
+Child process to stdout : 2924
+Child process to stdout : 2925
+Child process to stdout : 2926
+Child process to stdout : 2927
+Child process to stdout : 2928
+Child process to stdout : 2929
+Child process to stdout : 2930
+Child process to stdout : 2931
+Child process to stdout : 2932
+Child process to stdout : 2933
+Child process to stdout : 2934
+Child process to stdout : 2935
+Child process to stdout : 2936
+Child process to stdout : 2937
+Child process to stdout : 2938
+Child process to stdout : 2939
+Child process to stdout : 2940
+Child process to stdout : 2941
+Child process to stdout : 2942
+Child process to stdout : 2943
+Child process to stdout : 2944
+Child process to stdout : 2945
+Child process to stdout : 2946
+Child process to stdout : 2947
+Child process to stdout : 2948
+Child process to stdout : 2949
+Child process to stdout : 2950
+Child process to stdout : 2951
+Child process to stdout : 2952
+Child process to stdout : 2953
+Child process to stdout : 2954
+Child process to stdout : 2955
+Child process to stdout : 2956
+Child process to stdout : 2957
+Child process to stdout : 2958
+Child process to stdout : 2959
+Child process to stdout : 2960
+Child process to stdout : 2961
+Child process to stdout : 2962
+Child process to stdout : 2963
+Child process to stdout : 2964
+Child process to stdout : 2965
+Child process to stdout : 2966
+Child process to stdout : 2967
+Child process to stdout : 2968
+Child process to stdout : 2969
+Child process to stdout : 2970
+Child process to stdout : 2971
+Child process to stdout : 2972
+Child process to stdout : 2973
+Child process to stdout : 2974
+Child process to stdout : 2975
+Child process to stdout : 2976
+Child process to stdout : 2977
+Child process to stdout : 2978
+Child process to stdout : 2979
+Child process to stdout : 2980
+Child process to stdout : 2981
+Child process to stdout : 2982
+Child process to stdout : 2983
+Child process to stdout : 2984
+Child process to stdout : 2985
+Child process to stdout : 2986
+Child process to stdout : 2987
+Child process to stdout : 2988
+Child process to stdout : 2989
+Child process to stdout : 2990
+Child process to stdout : 2991
+Child process to stdout : 2992
+Child process to stdout : 2993
+Child process to stdout : 2994
+Child process to stdout : 2995
+Child process to stdout : 2996
+Child process to stdout : 2997
+Child process to stdout : 2998
+Child process to stdout : 2999
+Child process to stdout : 3000
+Child process to stdout : 3001
+Child process to stdout : 3002
+Child process to stdout : 3003
+Child process to stdout : 3004
+Child process to stdout : 3005
+Child process to stdout : 3006
+Child process to stdout : 3007
+Child process to stdout : 3008
+Child process to stdout : 3009
+Child process to stdout : 3010
+Child process to stdout : 3011
+Child process to stdout : 3012
+Child process to stdout : 3013
+Child process to stdout : 3014
+Child process to stdout : 3015
+Child process to stdout : 3016
+Child process to stdout : 3017
+Child process to stdout : 3018
+Child process to stdout : 3019
+Child process to stdout : 3020
+Child process to stdout : 3021
+Child process to stdout : 3022
+Child process to stdout : 3023
+Child process to stdout : 3024
+Child process to stdout : 3025
+Child process to stdout : 3026
+Child process to stdout : 3027
+Child process to stdout : 3028
+Child process to stdout : 3029
+Child process to stdout : 3030
+Child process to stdout : 3031
+Child process to stdout : 3032
+Child process to stdout : 3033
+Child process to stdout : 3034
+Child process to stdout : 3035
+Child process to stdout : 3036
+Child process to stdout : 3037
+Child process to stdout : 3038
+Child process to stdout : 3039
+Child process to stdout : 3040
+Child process to stdout : 3041
+Child process to stdout : 3042
+Child process to stdout : 3043
+Child process to stdout : 3044
+Child process to stdout : 3045
+Child process to stdout : 3046
+Child process to stdout : 3047
+Child process to stdout : 3048
+Child process to stdout : 3049
+Child process to stdout : 3050
+Child process to stdout : 3051
+Child process to stdout : 3052
+Child process to stdout : 3053
+Child process to stdout : 3054
+Child process to stdout : 3055
+Child process to stdout : 3056
+Child process to stdout : 3057
+Child process to stdout : 3058
+Child process to stdout : 3059
+Child process to stdout : 3060
+Child process to stdout : 3061
+Child process to stdout : 3062
+Child process to stdout : 3063
+Child process to stdout : 3064
+Child process to stdout : 3065
+Child process to stdout : 3066
+Child process to stdout : 3067
+Child process to stdout : 3068
+Child process to stdout : 3069
+Child process to stdout : 3070
+Child process to stdout : 3071
+Child process to stdout : 3072
+Child process to stdout : 3073
+Child process to stdout : 3074
+Child process to stdout : 3075
+Child process to stdout : 3076
+Child process to stdout : 3077
+Child process to stdout : 3078
+Child process to stdout : 3079
+Child process to stdout : 3080
+Child process to stdout : 3081
+Child process to stdout : 3082
+Child process to stdout : 3083
+Child process to stdout : 3084
+Child process to stdout : 3085
+Child process to stdout : 3086
+Child process to stdout : 3087
+Child process to stdout : 3088
+Child process to stdout : 3089
+Child process to stdout : 3090
+Child process to stdout : 3091
+Child process to stdout : 3092
+Child process to stdout : 3093
+Child process to stdout : 3094
+Child process to stdout : 3095
+Child process to stdout : 3096
+Child process to stdout : 3097
+Child process to stdout : 3098
+Child process to stdout : 3099
+Child process to stdout : 3100
+Child process to stdout : 3101
+Child process to stdout : 3102
+Child process to stdout : 3103
+Child process to stdout : 3104
+Child process to stdout : 3105
+Child process to stdout : 3106
+Child process to stdout : 3107
+Child process to stdout : 3108
+Child process to stdout : 3109
+Child process to stdout : 3110
+Child process to stdout : 3111
+Child process to stdout : 3112
+Child process to stdout : 3113
+Child process to stdout : 3114
+Child process to stdout : 3115
+Child process to stdout : 3116
+Child process to stdout : 3117
+Child process to stdout : 3118
+Child process to stdout : 3119
+Child process to stdout : 3120
+Child process to stdout : 3121
+Child process to stdout : 3122
+Child process to stdout : 3123
+Child process to stdout : 3124
+Child process to stdout : 3125
+Child process to stdout : 3126
+Child process to stdout : 3127
+Child process to stdout : 3128
+Child process to stdout : 3129
+Child process to stdout : 3130
+Child process to stdout : 3131
+Child process to stdout : 3132
+Child process to stdout : 3133
+Child process to stdout : 3134
+Child process to stdout : 3135
+Child process to stdout : 3136
+Child process to stdout : 3137
+Child process to stdout : 3138
+Child process to stdout : 3139
+Child process to stdout : 3140
+Child process to stdout : 3141
+Child process to stdout : 3142
+Child process to stdout : 3143
+Child process to stdout : 3144
+Child process to stdout : 3145
+Child process to stdout : 3146
+Child process to stdout : 3147
+Child process to stdout : 3148
+Child process to stdout : 3149
+Child process to stdout : 3150
+Child process to stdout : 3151
+Child process to stdout : 3152
+Child process to stdout : 3153
+Child process to stdout : 3154
+Child process to stdout : 3155
+Child process to stdout : 3156
+Child process to stdout : 3157
+Child process to stdout : 3158
+Child process to stdout : 3159
+Child process to stdout : 3160
+Child process to stdout : 3161
+Child process to stdout : 3162
+Child process to stdout : 3163
+Child process to stdout : 3164
+Child process to stdout : 3165
+Child process to stdout : 3166
+Child process to stdout : 3167
+Child process to stdout : 3168
+Child process to stdout : 3169
+Child process to stdout : 3170
+Child process to stdout : 3171
+Child process to stdout : 3172
+Child process to stdout : 3173
+Child process to stdout : 3174
+Child process to stdout : 3175
+Child process to stdout : 3176
+Child process to stdout : 3177
+Child process to stdout : 3178
+Child process to stdout : 3179
+Child process to stdout : 3180
+Child process to stdout : 3181
+Child process to stdout : 3182
+Child process to stdout : 3183
+Child process to stdout : 3184
+Child process to stdout : 3185
+Child process to stdout : 3186
+Child process to stdout : 3187
+Child process to stdout : 3188
+Child process to stdout : 3189
+Child process to stdout : 3190
+Child process to stdout : 3191
+Child process to stdout : 3192
+Child process to stdout : 3193
+Child process to stdout : 3194
+Child process to stdout : 3195
+Child process to stdout : 3196
+Child process to stdout : 3197
+Child process to stdout : 3198
+Child process to stdout : 3199
+Child process to stdout : 3200
+Child process to stdout : 3201
+Child process to stdout : 3202
+Child process to stdout : 3203
+Child process to stdout : 3204
+Child process to stdout : 3205
+Child process to stdout : 3206
+Child process to stdout : 3207
+Child process to stdout : 3208
+Child process to stdout : 3209
+Child process to stdout : 3210
+Child process to stdout : 3211
+Child process to stdout : 3212
+Child process to stdout : 3213
+Child process to stdout : 3214
+Child process to stdout : 3215
+Child process to stdout : 3216
+Child process to stdout : 3217
+Child process to stdout : 3218
+Child process to stdout : 3219
+Child process to stdout : 3220
+Child process to stdout : 3221
+Child process to stdout : 3222
+Child process to stdout : 3223
+Child process to stdout : 3224
+Child process to stdout : 3225
+Child process to stdout : 3226
+Child process to stdout : 3227
+Child process to stdout : 3228
+Child process to stdout : 3229
+Child process to stdout : 3230
+Child process to stdout : 3231
+Child process to stdout : 3232
+Child process to stdout : 3233
+Child process to stdout : 3234
+Child process to stdout : 3235
+Child process to stdout : 3236
+Child process to stdout : 3237
+Child process to stdout : 3238
+Child process to stdout : 3239
+Child process to stdout : 3240
+Child process to stdout : 3241
+Child process to stdout : 3242
+Child process to stdout : 3243
+Child process to stdout : 3244
+Child process to stdout : 3245
+Child process to stdout : 3246
+Child process to stdout : 3247
+Child process to stdout : 3248
+Child process to stdout : 3249
+Child process to stdout : 3250
+Child process to stdout : 3251
+Child process to stdout : 3252
+Child process to stdout : 3253
+Child process to stdout : 3254
+Child process to stdout : 3255
+Child process to stdout : 3256
+Child process to stdout : 3257
+Child process to stdout : 3258
+Child process to stdout : 3259
+Child process to stdout : 3260
+Child process to stdout : 3261
+Child process to stdout : 3262
+Child process to stdout : 3263
+Child process to stdout : 3264
+Child process to stdout : 3265
+Child process to stdout : 3266
+Child process to stdout : 3267
+Child process to stdout : 3268
+Child process to stdout : 3269
+Child process to stdout : 3270
+Child process to stdout : 3271
+Child process to stdout : 3272
+Child process to stdout : 3273
+Child process to stdout : 3274
+Child process to stdout : 3275
+Child process to stdout : 3276
+Child process to stdout : 3277
+Child process to stdout : 3278
+Child process to stdout : 3279
+Child process to stdout : 3280
+Child process to stdout : 3281
+Child process to stdout : 3282
+Child process to stdout : 3283
+Child process to stdout : 3284
+Child process to stdout : 3285
+Child process to stdout : 3286
+Child process to stdout : 3287
+Child process to stdout : 3288
+Child process to stdout : 3289
+Child process to stdout : 3290
+Child process to stdout : 3291
+Child process to stdout : 3292
+Child process to stdout : 3293
+Child process to stdout : 3294
+Child process to stdout : 3295
+Child process to stdout : 3296
+Child process to stdout : 3297
+Child process to stdout : 3298
+Child process to stdout : 3299
+Child process to stdout : 3300
+Child process to stdout : 3301
+Child process to stdout : 3302
+Child process to stdout : 3303
+Child process to stdout : 3304
+Child process to stdout : 3305
+Child process to stdout : 3306
+Child process to stdout : 3307
+Child process to stdout : 3308
+Child process to stdout : 3309
+Child process to stdout : 3310
+Child process to stdout : 3311
+Child process to stdout : 3312
+Child process to stdout : 3313
+Child process to stdout : 3314
+Child process to stdout : 3315
+Child process to stdout : 3316
+Child process to stdout : 3317
+Child process to stdout : 3318
+Child process to stdout : 3319
+Child process to stdout : 3320
+Child process to stdout : 3321
+Child process to stdout : 3322
+Child process to stdout : 3323
+Child process to stdout : 3324
+Child process to stdout : 3325
+Child process to stdout : 3326
+Child process to stdout : 3327
+Child process to stdout : 3328
+Child process to stdout : 3329
+Child process to stdout : 3330
+Child process to stdout : 3331
+Child process to stdout : 3332
+Child process to stdout : 3333
+Child process to stdout : 3334
+Child process to stdout : 3335
+Child process to stdout : 3336
+Child process to stdout : 3337
+Child process to stdout : 3338
+Child process to stdout : 3339
+Child process to stdout : 3340
+Child process to stdout : 3341
+Child process to stdout : 3342
+Child process to stdout : 3343
+Child process to stdout : 3344
+Child process to stdout : 3345
+Child process to stdout : 3346
+Child process to stdout : 3347
+Child process to stdout : 3348
+Child process to stdout : 3349
+Child process to stdout : 3350
+Child process to stdout : 3351
+Child process to stdout : 3352
+Child process to stdout : 3353
+Child process to stdout : 3354
+Child process to stdout : 3355
+Child process to stdout : 3356
+Child process to stdout : 3357
+Child process to stdout : 3358
+Child process to stdout : 3359
+Child process to stdout : 3360
+Child process to stdout : 3361
+Child process to stdout : 3362
+Child process to stdout : 3363
+Child process to stdout : 3364
+Child process to stdout : 3365
+Child process to stdout : 3366
+Child process to stdout : 3367
+Child process to stdout : 3368
+Child process to stdout : 3369
+Child process to stdout : 3370
+Child process to stdout : 3371
+Child process to stdout : 3372
+Child process to stdout : 3373
+Child process to stdout : 3374
+Child process to stdout : 3375
+Child process to stdout : 3376
+Child process to stdout : 3377
+Child process to stdout : 3378
+Child process to stdout : 3379
+Child process to stdout : 3380
+Child process to stdout : 3381
+Child process to stdout : 3382
+Child process to stdout : 3383
+Child process to stdout : 3384
+Child process to stdout : 3385
+Child process to stdout : 3386
+Child process to stdout : 3387
+Child process to stdout : 3388
+Child process to stdout : 3389
+Child process to stdout : 3390
+Child process to stdout : 3391
+Child process to stdout : 3392
+Child process to stdout : 3393
+Child process to stdout : 3394
+Child process to stdout : 3395
+Child process to stdout : 3396
+Child process to stdout : 3397
+Child process to stdout : 3398
+Child process to stdout : 3399
+Child process to stdout : 3400
+Child process to stdout : 3401
+Child process to stdout : 3402
+Child process to stdout : 3403
+Child process to stdout : 3404
+Child process to stdout : 3405
+Child process to stdout : 3406
+Child process to stdout : 3407
+Child process to stdout : 3408
+Child process to stdout : 3409
+Child process to stdout : 3410
+Child process to stdout : 3411
+Child process to stdout : 3412
+Child process to stdout : 3413
+Child process to stdout : 3414
+Child process to stdout : 3415
+Child process to stdout : 3416
+Child process to stdout : 3417
+Child process to stdout : 3418
+Child process to stdout : 3419
+Child process to stdout : 3420
+Child process to stdout : 3421
+Child process to stdout : 3422
+Child process to stdout : 3423
+Child process to stdout : 3424
+Child process to stdout : 3425
+Child process to stdout : 3426
+Child process to stdout : 3427
+Child process to stdout : 3428
+Child process to stdout : 3429
+Child process to stdout : 3430
+Child process to stdout : 3431
+Child process to stdout : 3432
+Child process to stdout : 3433
+Child process to stdout : 3434
+Child process to stdout : 3435
+Child process to stdout : 3436
+Child process to stdout : 3437
+Child process to stdout : 3438
+Child process to stdout : 3439
+Child process to stdout : 3440
+Child process to stdout : 3441
+Child process to stdout : 3442
+Child process to stdout : 3443
+Child process to stdout : 3444
+Child process to stdout : 3445
+Child process to stdout : 3446
+Child process to stdout : 3447
+Child process to stdout : 3448
+Child process to stdout : 3449
+Child process to stdout : 3450
+Child process to stdout : 3451
+Child process to stdout : 3452
+Child process to stdout : 3453
+Child process to stdout : 3454
+Child process to stdout : 3455
+Child process to stdout : 3456
+Child process to stdout : 3457
+Child process to stdout : 3458
+Child process to stdout : 3459
+Child process to stdout : 3460
+Child process to stdout : 3461
+Child process to stdout : 3462
+Child process to stdout : 3463
+Child process to stdout : 3464
+Child process to stdout : 3465
+Child process to stdout : 3466
+Child process to stdout : 3467
+Child process to stdout : 3468
+Child process to stdout : 3469
+Child process to stdout : 3470
+Child process to stdout : 3471
+Child process to stdout : 3472
+Child process to stdout : 3473
+Child process to stdout : 3474
+Child process to stdout : 3475
+Child process to stdout : 3476
+Child process to stdout : 3477
+Child process to stdout : 3478
+Child process to stdout : 3479
+Child process to stdout : 3480
+Child process to stdout : 3481
+Child process to stdout : 3482
+Child process to stdout : 3483
+Child process to stdout : 3484
+Child process to stdout : 3485
+Child process to stdout : 3486
+Child process to stdout : 3487
+Child process to stdout : 3488
+Child process to stdout : 3489
+Child process to stdout : 3490
+Child process to stdout : 3491
+Child process to stdout : 3492
+Child process to stdout : 3493
+Child process to stdout : 3494
+Child process to stdout : 3495
+Child process to stdout : 3496
+Child process to stdout : 3497
+Child process to stdout : 3498
+Child process to stdout : 3499
+Child process to stdout : 3500
+Child process to stdout : 3501
+Child process to stdout : 3502
+Child process to stdout : 3503
+Child process to stdout : 3504
+Child process to stdout : 3505
+Child process to stdout : 3506
+Child process to stdout : 3507
+Child process to stdout : 3508
+Child process to stdout : 3509
+Child process to stdout : 3510
+Child process to stdout : 3511
+Child process to stdout : 3512
+Child process to stdout : 3513
+Child process to stdout : 3514
+Child process to stdout : 3515
+Child process to stdout : 3516
+Child process to stdout : 3517
+Child process to stdout : 3518
+Child process to stdout : 3519
+Child process to stdout : 3520
+Child process to stdout : 3521
+Child process to stdout : 3522
+Child process to stdout : 3523
+Child process to stdout : 3524
+Child process to stdout : 3525
+Child process to stdout : 3526
+Child process to stdout : 3527
+Child process to stdout : 3528
+Child process to stdout : 3529
+Child process to stdout : 3530
+Child process to stdout : 3531
+Child process to stdout : 3532
+Child process to stdout : 3533
+Child process to stdout : 3534
+Child process to stdout : 3535
+Child process to stdout : 3536
+Child process to stdout : 3537
+Child process to stdout : 3538
+Child process to stdout : 3539
+Child process to stdout : 3540
+Child process to stdout : 3541
+Child process to stdout : 3542
+Child process to stdout : 3543
+Child process to stdout : 3544
+Child process to stdout : 3545
+Child process to stdout : 3546
+Child process to stdout : 3547
+Child process to stdout : 3548
+Child process to stdout : 3549
+Child process to stdout : 3550
+Child process to stdout : 3551
+Child process to stdout : 3552
+Child process to stdout : 3553
+Child process to stdout : 3554
+Child process to stdout : 3555
+Child process to stdout : 3556
+Child process to stdout : 3557
+Child process to stdout : 3558
+Child process to stdout : 3559
+Child process to stdout : 3560
+Child process to stdout : 3561
+Child process to stdout : 3562
+Child process to stdout : 3563
+Child process to stdout : 3564
+Child process to stdout : 3565
+Child process to stdout : 3566
+Child process to stdout : 3567
+Child process to stdout : 3568
+Child process to stdout : 3569
+Child process to stdout : 3570
+Child process to stdout : 3571
+Child process to stdout : 3572
+Child process to stdout : 3573
+Child process to stdout : 3574
+Child process to stdout : 3575
+Child process to stdout : 3576
+Child process to stdout : 3577
+Child process to stdout : 3578
+Child process to stdout : 3579
+Child process to stdout : 3580
+Child process to stdout : 3581
+Child process to stdout : 3582
+Child process to stdout : 3583
+Child process to stdout : 3584
+Child process to stdout : 3585
+Child process to stdout : 3586
+Child process to stdout : 3587
+Child process to stdout : 3588
+Child process to stdout : 3589
+Child process to stdout : 3590
+Child process to stdout : 3591
+Child process to stdout : 3592
+Child process to stdout : 3593
+Child process to stdout : 3594
+Child process to stdout : 3595
+Child process to stdout : 3596
+Child process to stdout : 3597
+Child process to stdout : 3598
+Child process to stdout : 3599
+Child process to stdout : 3600
+Child process to stdout : 3601
+Child process to stdout : 3602
+Child process to stdout : 3603
+Child process to stdout : 3604
+Child process to stdout : 3605
+Child process to stdout : 3606
+Child process to stdout : 3607
+Child process to stdout : 3608
+Child process to stdout : 3609
+Child process to stdout : 3610
+Child process to stdout : 3611
+Child process to stdout : 3612
+Child process to stdout : 3613
+Child process to stdout : 3614
+Child process to stdout : 3615
+Child process to stdout : 3616
+Child process to stdout : 3617
+Child process to stdout : 3618
+Child process to stdout : 3619
+Child process to stdout : 3620
+Child process to stdout : 3621
+Child process to stdout : 3622
+Child process to stdout : 3623
+Child process to stdout : 3624
+Child process to stdout : 3625
+Child process to stdout : 3626
+Child process to stdout : 3627
+Child process to stdout : 3628
+Child process to stdout : 3629
+Child process to stdout : 3630
+Child process to stdout : 3631
+Child process to stdout : 3632
+Child process to stdout : 3633
+Child process to stdout : 3634
+Child process to stdout : 3635
+Child process to stdout : 3636
+Child process to stdout : 3637
+Child process to stdout : 3638
+Child process to stdout : 3639
+Child process to stdout : 3640
+Child process to stdout : 3641
+Child process to stdout : 3642
+Child process to stdout : 3643
+Child process to stdout : 3644
+Child process to stdout : 3645
+Child process to stdout : 3646
+Child process to stdout : 3647
+Child process to stdout : 3648
+Child process to stdout : 3649
+Child process to stdout : 3650
+Child process to stdout : 3651
+Child process to stdout : 3652
+Child process to stdout : 3653
+Child process to stdout : 3654
+Child process to stdout : 3655
+Child process to stdout : 3656
+Child process to stdout : 3657
+Child process to stdout : 3658
+Child process to stdout : 3659
+Child process to stdout : 3660
+Child process to stdout : 3661
+Child process to stdout : 3662
+Child process to stdout : 3663
+Child process to stdout : 3664
+Child process to stdout : 3665
+Child process to stdout : 3666
+Child process to stdout : 3667
+Child process to stdout : 3668
+Child process to stdout : 3669
+Child process to stdout : 3670
+Child process to stdout : 3671
+Child process to stdout : 3672
+Child process to stdout : 3673
+Child process to stdout : 3674
+Child process to stdout : 3675
+Child process to stdout : 3676
+Child process to stdout : 3677
+Child process to stdout : 3678
+Child process to stdout : 3679
+Child process to stdout : 3680
+Child process to stdout : 3681
+Child process to stdout : 3682
+Child process to stdout : 3683
+Child process to stdout : 3684
+Child process to stdout : 3685
+Child process to stdout : 3686
+Child process to stdout : 3687
+Child process to stdout : 3688
+Child process to stdout : 3689
+Child process to stdout : 3690
+Child process to stdout : 3691
+Child process to stdout : 3692
+Child process to stdout : 3693
+Child process to stdout : 3694
+Child process to stdout : 3695
+Child process to stdout : 3696
+Child process to stdout : 3697
+Child process to stdout : 3698
+Child process to stdout : 3699
+Child process to stdout : 3700
+Child process to stdout : 3701
+Child process to stdout : 3702
+Child process to stdout : 3703
+Child process to stdout : 3704
+Child process to stdout : 3705
+Child process to stdout : 3706
+Child process to stdout : 3707
+Child process to stdout : 3708
+Child process to stdout : 3709
+Child process to stdout : 3710
+Child process to stdout : 3711
+Child process to stdout : 3712
+Child process to stdout : 3713
+Child process to stdout : 3714
+Child process to stdout : 3715
+Child process to stdout : 3716
+Child process to stdout : 3717
+Child process to stdout : 3718
+Child process to stdout : 3719
+Child process to stdout : 3720
+Child process to stdout : 3721
+Child process to stdout : 3722
+Child process to stdout : 3723
+Child process to stdout : 3724
+Child process to stdout : 3725
+Child process to stdout : 3726
+Child process to stdout : 3727
+Child process to stdout : 3728
+Child process to stdout : 3729
+Child process to stdout : 3730
+Child process to stdout : 3731
+Child process to stdout : 3732
+Child process to stdout : 3733
+Child process to stdout : 3734
+Child process to stdout : 3735
+Child process to stdout : 3736
+Child process to stdout : 3737
+Child process to stdout : 3738
+Child process to stdout : 3739
+Child process to stdout : 3740
+Child process to stdout : 3741
+Child process to stdout : 3742
+Child process to stdout : 3743
+Child process to stdout : 3744
+Child process to stdout : 3745
+Child process to stdout : 3746
+Child process to stdout : 3747
+Child process to stdout : 3748
+Child process to stdout : 3749
+Child process to stdout : 3750
+Child process to stdout : 3751
+Child process to stdout : 3752
+Child process to stdout : 3753
+Child process to stdout : 3754
+Child process to stdout : 3755
+Child process to stdout : 3756
+Child process to stdout : 3757
+Child process to stdout : 3758
+Child process to stdout : 3759
+Child process to stdout : 3760
+Child process to stdout : 3761
+Child process to stdout : 3762
+Child process to stdout : 3763
+Child process to stdout : 3764
+Child process to stdout : 3765
+Child process to stdout : 3766
+Child process to stdout : 3767
+Child process to stdout : 3768
+Child process to stdout : 3769
+Child process to stdout : 3770
+Child process to stdout : 3771
+Child process to stdout : 3772
+Child process to stdout : 3773
+Child process to stdout : 3774
+Child process to stdout : 3775
+Child process to stdout : 3776
+Child process to stdout : 3777
+Child process to stdout : 3778
+Child process to stdout : 3779
+Child process to stdout : 3780
+Child process to stdout : 3781
+Child process to stdout : 3782
+Child process to stdout : 3783
+Child process to stdout : 3784
+Child process to stdout : 3785
+Child process to stdout : 3786
+Child process to stdout : 3787
+Child process to stdout : 3788
+Child process to stdout : 3789
+Child process to stdout : 3790
+Child process to stdout : 3791
+Child process to stdout : 3792
+Child process to stdout : 3793
+Child process to stdout : 3794
+Child process to stdout : 3795
+Child process to stdout : 3796
+Child process to stdout : 3797
+Child process to stdout : 3798
+Child process to stdout : 3799
+Child process to stdout : 3800
+Child process to stdout : 3801
+Child process to stdout : 3802
+Child process to stdout : 3803
+Child process to stdout : 3804
+Child process to stdout : 3805
+Child process to stdout : 3806
+Child process to stdout : 3807
+Child process to stdout : 3808
+Child process to stdout : 3809
+Child process to stdout : 3810
+Child process to stdout : 3811
+Child process to stdout : 3812
+Child process to stdout : 3813
+Child process to stdout : 3814
+Child process to stdout : 3815
+Child process to stdout : 3816
+Child process to stdout : 3817
+Child process to stdout : 3818
+Child process to stdout : 3819
+Child process to stdout : 3820
+Child process to stdout : 3821
+Child process to stdout : 3822
+Child process to stdout : 3823
+Child process to stdout : 3824
+Child process to stdout : 3825
+Child process to stdout : 3826
+Child process to stdout : 3827
+Child process to stdout : 3828
+Child process to stdout : 3829
+Child process to stdout : 3830
+Child process to stdout : 3831
+Child process to stdout : 3832
+Child process to stdout : 3833
+Child process to stdout : 3834
+Child process to stdout : 3835
+Child process to stdout : 3836
+Child process to stdout : 3837
+Child process to stdout : 3838
+Child process to stdout : 3839
+Child process to stdout : 3840
+Child process to stdout : 3841
+Child process to stdout : 3842
+Child process to stdout : 3843
+Child process to stdout : 3844
+Child process to stdout : 3845
+Child process to stdout : 3846
+Child process to stdout : 3847
+Child process to stdout : 3848
+Child process to stdout : 3849
+Child process to stdout : 3850
+Child process to stdout : 3851
+Child process to stdout : 3852
+Child process to stdout : 3853
+Child process to stdout : 3854
+Child process to stdout : 3855
+Child process to stdout : 3856
+Child process to stdout : 3857
+Child process to stdout : 3858
+Child process to stdout : 3859
+Child process to stdout : 3860
+Child process to stdout : 3861
+Child process to stdout : 3862
+Child process to stdout : 3863
+Child process to stdout : 3864
+Child process to stdout : 3865
+Child process to stdout : 3866
+Child process to stdout : 3867
+Child process to stdout : 3868
+Child process to stdout : 3869
+Child process to stdout : 3870
+Child process to stdout : 3871
+Child process to stdout : 3872
+Child process to stdout : 3873
+Child process to stdout : 3874
+Child process to stdout : 3875
+Child process to stdout : 3876
+Child process to stdout : 3877
+Child process to stdout : 3878
+Child process to stdout : 3879
+Child process to stdout : 3880
+Child process to stdout : 3881
+Child process to stdout : 3882
+Child process to stdout : 3883
+Child process to stdout : 3884
+Child process to stdout : 3885
+Child process to stdout : 3886
+Child process to stdout : 3887
+Child process to stdout : 3888
+Child process to stdout : 3889
+Child process to stdout : 3890
+Child process to stdout : 3891
+Child process to stdout : 3892
+Child process to stdout : 3893
+Child process to stdout : 3894
+Child process to stdout : 3895
+Child process to stdout : 3896
+Child process to stdout : 3897
+Child process to stdout : 3898
+Child process to stdout : 3899
+Child process to stdout : 3900
+Child process to stdout : 3901
+Child process to stdout : 3902
+Child process to stdout : 3903
+Child process to stdout : 3904
+Child process to stdout : 3905
+Child process to stdout : 3906
+Child process to stdout : 3907
+Child process to stdout : 3908
+Child process to stdout : 3909
+Child process to stdout : 3910
+Child process to stdout : 3911
+Child process to stdout : 3912
+Child process to stdout : 3913
+Child process to stdout : 3914
+Child process to stdout : 3915
+Child process to stdout : 3916
+Child process to stdout : 3917
+Child process to stdout : 3918
+Child process to stdout : 3919
+Child process to stdout : 3920
+Child process to stdout : 3921
+Child process to stdout : 3922
+Child process to stdout : 3923
+Child process to stdout : 3924
+Child process to stdout : 3925
+Child process to stdout : 3926
+Child process to stdout : 3927
+Child process to stdout : 3928
+Child process to stdout : 3929
+Child process to stdout : 3930
+Child process to stdout : 3931
+Child process to stdout : 3932
+Child process to stdout : 3933
+Child process to stdout : 3934
+Child process to stdout : 3935
+Child process to stdout : 3936
+Child process to stdout : 3937
+Child process to stdout : 3938
+Child process to stdout : 3939
+Child process to stdout : 3940
+Child process to stdout : 3941
+Child process to stdout : 3942
+Child process to stdout : 3943
+Child process to stdout : 3944
+Child process to stdout : 3945
+Child process to stdout : 3946
+Child process to stdout : 3947
+Child process to stdout : 3948
+Child process to stdout : 3949
+Child process to stdout : 3950
+Child process to stdout : 3951
+Child process to stdout : 3952
+Child process to stdout : 3953
+Child process to stdout : 3954
+Child process to stdout : 3955
+Child process to stdout : 3956
+Child process to stdout : 3957
+Child process to stdout : 3958
+Child process to stdout : 3959
+Child process to stdout : 3960
+Child process to stdout : 3961
+Child process to stdout : 3962
+Child process to stdout : 3963
+Child process to stdout : 3964
+Child process to stdout : 3965
+Child process to stdout : 3966
+Child process to stdout : 3967
+Child process to stdout : 3968
+Child process to stdout : 3969
+Child process to stdout : 3970
+Child process to stdout : 3971
+Child process to stdout : 3972
+Child process to stdout : 3973
+Child process to stdout : 3974
+Child process to stdout : 3975
+Child process to stdout : 3976
+Child process to stdout : 3977
+Child process to stdout : 3978
+Child process to stdout : 3979
+Child process to stdout : 3980
+Child process to stdout : 3981
+Child process to stdout : 3982
+Child process to stdout : 3983
+Child process to stdout : 3984
+Child process to stdout : 3985
+Child process to stdout : 3986
+Child process to stdout : 3987
+Child process to stdout : 3988
+Child process to stdout : 3989
+Child process to stdout : 3990
+Child process to stdout : 3991
+Child process to stdout : 3992
+Child process to stdout : 3993
+Child process to stdout : 3994
+Child process to stdout : 3995
+Child process to stdout : 3996
+Child process to stdout : 3997
+Child process to stdout : 3998
+Child process to stdout : 3999
+Child process to stdout : 4000
+Child process to stdout : 4001
+Child process to stdout : 4002
+Child process to stdout : 4003
+Child process to stdout : 4004
+Child process to stdout : 4005
+Child process to stdout : 4006
+Child process to stdout : 4007
+Child process to stdout : 4008
+Child process to stdout : 4009
+Child process to stdout : 4010
+Child process to stdout : 4011
+Child process to stdout : 4012
+Child process to stdout : 4013
+Child process to stdout : 4014
+Child process to stdout : 4015
+Child process to stdout : 4016
+Child process to stdout : 4017
+Child process to stdout : 4018
+Child process to stdout : 4019
+Child process to stdout : 4020
+Child process to stdout : 4021
+Child process to stdout : 4022
+Child process to stdout : 4023
+Child process to stdout : 4024
+Child process to stdout : 4025
+Child process to stdout : 4026
+Child process to stdout : 4027
+Child process to stdout : 4028
+Child process to stdout : 4029
+Child process to stdout : 4030
+Child process to stdout : 4031
+Child process to stdout : 4032
+Child process to stdout : 4033
+Child process to stdout : 4034
+Child process to stdout : 4035
+Child process to stdout : 4036
+Child process to stdout : 4037
+Child process to stdout : 4038
+Child process to stdout : 4039
+Child process to stdout : 4040
+Child process to stdout : 4041
+Child process to stdout : 4042
+Child process to stdout : 4043
+Child process to stdout : 4044
+Child process to stdout : 4045
+Child process to stdout : 4046
+Child process to stdout : 4047
+Child process to stdout : 4048
+Child process to stdout : 4049
+Child process to stdout : 4050
+Child process to stdout : 4051
+Child process to stdout : 4052
+Child process to stdout : 4053
+Child process to stdout : 4054
+Child process to stdout : 4055
+Child process to stdout : 4056
+Child process to stdout : 4057
+Child process to stdout : 4058
+Child process to stdout : 4059
+Child process to stdout : 4060
+Child process to stdout : 4061
+Child process to stdout : 4062
+Child process to stdout : 4063
+Child process to stdout : 4064
+Child process to stdout : 4065
+Child process to stdout : 4066
+Child process to stdout : 4067
+Child process to stdout : 4068
+Child process to stdout : 4069
+Child process to stdout : 4070
+Child process to stdout : 4071
+Child process to stdout : 4072
+Child process to stdout : 4073
+Child process to stdout : 4074
+Child process to stdout : 4075
+Child process to stdout : 4076
+Child process to stdout : 4077
+Child process to stdout : 4078
+Child process to stdout : 4079
+Child process to stdout : 4080
+Child process to stdout : 4081
+Child process to stdout : 4082
+Child process to stdout : 4083
+Child process to stdout : 4084
+Child process to stdout : 4085
+Child process to stdout : 4086
+Child process to stdout : 4087
+Child process to stdout : 4088
+Child process to stdout : 4089
+Child process to stdout : 4090
+Child process to stdout : 4091
+Child process to stdout : 4092
+Child process to stdout : 4093
+Child process to stdout : 4094
+Child process to stdout : 4095
+Child process to stdout : 4096
+Child process to stdout : 4097
+Child process to stdout : 4098
+Child process to stdout : 4099
+Child process to stdout : 4100
+Child process to stdout : 4101
+Child process to stdout : 4102
+Child process to stdout : 4103
+Child process to stdout : 4104
+Child process to stdout : 4105
+Child process to stdout : 4106
+Child process to stdout : 4107
+Child process to stdout : 4108
+Child process to stdout : 4109
+Child process to stdout : 4110
+Child process to stdout : 4111
+Child process to stdout : 4112
+Child process to stdout : 4113
+Child process to stdout : 4114
+Child process to stdout : 4115
+Child process to stdout : 4116
+Child process to stdout : 4117
+Child process to stdout : 4118
+Child process to stdout : 4119
+Child process to stdout : 4120
+Child process to stdout : 4121
+Child process to stdout : 4122
+Child process to stdout : 4123
+Child process to stdout : 4124
+Child process to stdout : 4125
+Child process to stdout : 4126
+Child process to stdout : 4127
+Child process to stdout : 4128
+Child process to stdout : 4129
+Child process to stdout : 4130
+Child process to stdout : 4131
+Child process to stdout : 4132
+Child process to stdout : 4133
+Child process to stdout : 4134
+Child process to stdout : 4135
+Child process to stdout : 4136
+Child process to stdout : 4137
+Child process to stdout : 4138
+Child process to stdout : 4139
+Child process to stdout : 4140
+Child process to stdout : 4141
+Child process to stdout : 4142
+Child process to stdout : 4143
+Child process to stdout : 4144
+Child process to stdout : 4145
+Child process to stdout : 4146
+Child process to stdout : 4147
+Child process to stdout : 4148
+Child process to stdout : 4149
+Child process to stdout : 4150
+Child process to stdout : 4151
+Child process to stdout : 4152
+Child process to stdout : 4153
+Child process to stdout : 4154
+Child process to stdout : 4155
+Child process to stdout : 4156
+Child process to stdout : 4157
+Child process to stdout : 4158
+Child process to stdout : 4159
+Child process to stdout : 4160
+Child process to stdout : 4161
+Child process to stdout : 4162
+Child process to stdout : 4163
+Child process to stdout : 4164
+Child process to stdout : 4165
+Child process to stdout : 4166
+Child process to stdout : 4167
+Child process to stdout : 4168
+Child process to stdout : 4169
+Child process to stdout : 4170
+Child process to stdout : 4171
+Child process to stdout : 4172
+Child process to stdout : 4173
+Child process to stdout : 4174
+Child process to stdout : 4175
+Child process to stdout : 4176
+Child process to stdout : 4177
+Child process to stdout : 4178
+Child process to stdout : 4179
+Child process to stdout : 4180
+Child process to stdout : 4181
+Child process to stdout : 4182
+Child process to stdout : 4183
+Child process to stdout : 4184
+Child process to stdout : 4185
+Child process to stdout : 4186
+Child process to stdout : 4187
+Child process to stdout : 4188
+Child process to stdout : 4189
+Child process to stdout : 4190
+Child process to stdout : 4191
+Child process to stdout : 4192
+Child process to stdout : 4193
+Child process to stdout : 4194
+Child process to stdout : 4195
+Child process to stdout : 4196
+Child process to stdout : 4197
+Child process to stdout : 4198
+Child process to stdout : 4199
+Child process to stdout : 4200
+Child process to stdout : 4201
+Child process to stdout : 4202
+Child process to stdout : 4203
+Child process to stdout : 4204
+Child process to stdout : 4205
+Child process to stdout : 4206
+Child process to stdout : 4207
+Child process to stdout : 4208
+Child process to stdout : 4209
+Child process to stdout : 4210
+Child process to stdout : 4211
+Child process to stdout : 4212
+Child process to stdout : 4213
+Child process to stdout : 4214
+Child process to stdout : 4215
+Child process to stdout : 4216
+Child process to stdout : 4217
+Child process to stdout : 4218
+Child process to stdout : 4219
+Child process to stdout : 4220
+Child process to stdout : 4221
+Child process to stdout : 4222
+Child process to stdout : 4223
+Child process to stdout : 4224
+Child process to stdout : 4225
+Child process to stdout : 4226
+Child process to stdout : 4227
+Child process to stdout : 4228
+Child process to stdout : 4229
+Child process to stdout : 4230
+Child process to stdout : 4231
+Child process to stdout : 4232
+Child process to stdout : 4233
+Child process to stdout : 4234
+Child process to stdout : 4235
+Child process to stdout : 4236
+Child process to stdout : 4237
+Child process to stdout : 4238
+Child process to stdout : 4239
+Child process to stdout : 4240
+Child process to stdout : 4241
+Child process to stdout : 4242
+Child process to stdout : 4243
+Child process to stdout : 4244
+Child process to stdout : 4245
+Child process to stdout : 4246
+Child process to stdout : 4247
+Child process to stdout : 4248
+Child process to stdout : 4249
+Child process to stdout : 4250
+Child process to stdout : 4251
+Child process to stdout : 4252
+Child process to stdout : 4253
+Child process to stdout : 4254
+Child process to stdout : 4255
+Child process to stdout : 4256
+Child process to stdout : 4257
+Child process to stdout : 4258
+Child process to stdout : 4259
+Child process to stdout : 4260
+Child process to stdout : 4261
+Child process to stdout : 4262
+Child process to stdout : 4263
+Child process to stdout : 4264
+Child process to stdout : 4265
+Child process to stdout : 4266
+Child process to stdout : 4267
+Child process to stdout : 4268
+Child process to stdout : 4269
+Child process to stdout : 4270
+Child process to stdout : 4271
+Child process to stdout : 4272
+Child process to stdout : 4273
+Child process to stdout : 4274
+Child process to stdout : 4275
+Child process to stdout : 4276
+Child process to stdout : 4277
+Child process to stdout : 4278
+Child process to stdout : 4279
+Child process to stdout : 4280
+Child process to stdout : 4281
+Child process to stdout : 4282
+Child process to stdout : 4283
+Child process to stdout : 4284
+Child process to stdout : 4285
+Child process to stdout : 4286
+Child process to stdout : 4287
+Child process to stdout : 4288
+Child process to stdout : 4289
+Child process to stdout : 4290
+Child process to stdout : 4291
+Child process to stdout : 4292
+Child process to stdout : 4293
+Child process to stdout : 4294
+Child process to stdout : 4295
+Child process to stdout : 4296
+Child process to stdout : 4297
+Child process to stdout : 4298
+Child process to stdout : 4299
+Child process to stdout : 4300
+Child process to stdout : 4301
+Child process to stdout : 4302
+Child process to stdout : 4303
+Child process to stdout : 4304
+Child process to stdout : 4305
+Child process to stdout : 4306
+Child process to stdout : 4307
+Child process to stdout : 4308
+Child process to stdout : 4309
+Child process to stdout : 4310
+Child process to stdout : 4311
+Child process to stdout : 4312
+Child process to stdout : 4313
+Child process to stdout : 4314
+Child process to stdout : 4315
+Child process to stdout : 4316
+Child process to stdout : 4317
+Child process to stdout : 4318
+Child process to stdout : 4319
+Child process to stdout : 4320
+Child process to stdout : 4321
+Child process to stdout : 4322
+Child process to stdout : 4323
+Child process to stdout : 4324
+Child process to stdout : 4325
+Child process to stdout : 4326
+Child process to stdout : 4327
+Child process to stdout : 4328
+Child process to stdout : 4329
+Child process to stdout : 4330
+Child process to stdout : 4331
+Child process to stdout : 4332
+Child process to stdout : 4333
+Child process to stdout : 4334
+Child process to stdout : 4335
+Child process to stdout : 4336
+Child process to stdout : 4337
+Child process to stdout : 4338
+Child process to stdout : 4339
+Child process to stdout : 4340
+Child process to stdout : 4341
+Child process to stdout : 4342
+Child process to stdout : 4343
+Child process to stdout : 4344
+Child process to stdout : 4345
+Child process to stdout : 4346
+Child process to stdout : 4347
+Child process to stdout : 4348
+Child process to stdout : 4349
+Child process to stdout : 4350
+Child process to stdout : 4351
+Child process to stdout : 4352
+Child process to stdout : 4353
+Child process to stdout : 4354
+Child process to stdout : 4355
+Child process to stdout : 4356
+Child process to stdout : 4357
+Child process to stdout : 4358
+Child process to stdout : 4359
+Child process to stdout : 4360
+Child process to stdout : 4361
+Child process to stdout : 4362
+Child process to stdout : 4363
+Child process to stdout : 4364
+Child process to stdout : 4365
+Child process to stdout : 4366
+Child process to stdout : 4367
+Child process to stdout : 4368
+Child process to stdout : 4369
+Child process to stdout : 4370
+Child process to stdout : 4371
+Child process to stdout : 4372
+Child process to stdout : 4373
+Child process to stdout : 4374
+Child process to stdout : 4375
+Child process to stdout : 4376
+Child process to stdout : 4377
+Child process to stdout : 4378
+Child process to stdout : 4379
+Child process to stdout : 4380
+Child process to stdout : 4381
+Child process to stdout : 4382
+Child process to stdout : 4383
+Child process to stdout : 4384
+Child process to stdout : 4385
+Child process to stdout : 4386
+Child process to stdout : 4387
+Child process to stdout : 4388
+Child process to stdout : 4389
+Child process to stdout : 4390
+Child process to stdout : 4391
+Child process to stdout : 4392
+Child process to stdout : 4393
+Child process to stdout : 4394
+Child process to stdout : 4395
+Child process to stdout : 4396
+Child process to stdout : 4397
+Child process to stdout : 4398
+Child process to stdout : 4399
+Child process to stdout : 4400
+Child process to stdout : 4401
+Child process to stdout : 4402
+Child process to stdout : 4403
+Child process to stdout : 4404
+Child process to stdout : 4405
+Child process to stdout : 4406
+Child process to stdout : 4407
+Child process to stdout : 4408
+Child process to stdout : 4409
+Child process to stdout : 4410
+Child process to stdout : 4411
+Child process to stdout : 4412
+Child process to stdout : 4413
+Child process to stdout : 4414
+Child process to stdout : 4415
+Child process to stdout : 4416
+Child process to stdout : 4417
+Child process to stdout : 4418
+Child process to stdout : 4419
+Child process to stdout : 4420
+Child process to stdout : 4421
+Child process to stdout : 4422
+Child process to stdout : 4423
+Child process to stdout : 4424
+Child process to stdout : 4425
+Child process to stdout : 4426
+Child process to stdout : 4427
+Child process to stdout : 4428
+Child process to stdout : 4429
+Child process to stdout : 4430
+Child process to stdout : 4431
+Child process to stdout : 4432
+Child process to stdout : 4433
+Child process to stdout : 4434
+Child process to stdout : 4435
+Child process to stdout : 4436
+Child process to stdout : 4437
+Child process to stdout : 4438
+Child process to stdout : 4439
+Child process to stdout : 4440
+Child process to stdout : 4441
+Child process to stdout : 4442
+Child process to stdout : 4443
+Child process to stdout : 4444
+Child process to stdout : 4445
+Child process to stdout : 4446
+Child process to stdout : 4447
+Child process to stdout : 4448
+Child process to stdout : 4449
+Child process to stdout : 4450
+Child process to stdout : 4451
+Child process to stdout : 4452
+Child process to stdout : 4453
+Child process to stdout : 4454
+Child process to stdout : 4455
+Child process to stdout : 4456
+Child process to stdout : 4457
+Child process to stdout : 4458
+Child process to stdout : 4459
+Child process to stdout : 4460
+Child process to stdout : 4461
+Child process to stdout : 4462
+Child process to stdout : 4463
+Child process to stdout : 4464
+Child process to stdout : 4465
+Child process to stdout : 4466
+Child process to stdout : 4467
+Child process to stdout : 4468
+Child process to stdout : 4469
+Child process to stdout : 4470
+Child process to stdout : 4471
+Child process to stdout : 4472
+Child process to stdout : 4473
+Child process to stdout : 4474
+Child process to stdout : 4475
+Child process to stdout : 4476
+Child process to stdout : 4477
+Child process to stdout : 4478
+Child process to stdout : 4479
+Child process to stdout : 4480
+Child process to stdout : 4481
+Child process to stdout : 4482
+Child process to stdout : 4483
+Child process to stdout : 4484
+Child process to stdout : 4485
+Child process to stdout : 4486
+Child process to stdout : 4487
+Child process to stdout : 4488
+Child process to stdout : 4489
+Child process to stdout : 4490
+Child process to stdout : 4491
+Child process to stdout : 4492
+Child process to stdout : 4493
+Child process to stdout : 4494
+Child process to stdout : 4495
+Child process to stdout : 4496
+Child process to stdout : 4497
+Child process to stdout : 4498
+Child process to stdout : 4499
+Child process to stdout : 4500
+Child process to stdout : 4501
+Child process to stdout : 4502
+Child process to stdout : 4503
+Child process to stdout : 4504
+Child process to stdout : 4505
+Child process to stdout : 4506
+Child process to stdout : 4507
+Child process to stdout : 4508
+Child process to stdout : 4509
+Child process to stdout : 4510
+Child process to stdout : 4511
+Child process to stdout : 4512
+Child process to stdout : 4513
+Child process to stdout : 4514
+Child process to stdout : 4515
+Child process to stdout : 4516
+Child process to stdout : 4517
+Child process to stdout : 4518
+Child process to stdout : 4519
+Child process to stdout : 4520
+Child process to stdout : 4521
+Child process to stdout : 4522
+Child process to stdout : 4523
+Child process to stdout : 4524
+Child process to stdout : 4525
+Child process to stdout : 4526
+Child process to stdout : 4527
+Child process to stdout : 4528
+Child process to stdout : 4529
+Child process to stdout : 4530
+Child process to stdout : 4531
+Child process to stdout : 4532
+Child process to stdout : 4533
+Child process to stdout : 4534
+Child process to stdout : 4535
+Child process to stdout : 4536
+Child process to stdout : 4537
+Child process to stdout : 4538
+Child process to stdout : 4539
+Child process to stdout : 4540
+Child process to stdout : 4541
+Child process to stdout : 4542
+Child process to stdout : 4543
+Child process to stdout : 4544
+Child process to stdout : 4545
+Child process to stdout : 4546
+Child process to stdout : 4547
+Child process to stdout : 4548
+Child process to stdout : 4549
+Child process to stdout : 4550
+Child process to stdout : 4551
+Child process to stdout : 4552
+Child process to stdout : 4553
+Child process to stdout : 4554
+Child process to stdout : 4555
+Child process to stdout : 4556
+Child process to stdout : 4557
+Child process to stdout : 4558
+Child process to stdout : 4559
+Child process to stdout : 4560
+Child process to stdout : 4561
+Child process to stdout : 4562
+Child process to stdout : 4563
+Child process to stdout : 4564
+Child process to stdout : 4565
+Child process to stdout : 4566
+Child process to stdout : 4567
+Child process to stdout : 4568
+Child process to stdout : 4569
+Child process to stdout : 4570
+Child process to stdout : 4571
+Child process to stdout : 4572
+Child process to stdout : 4573
+Child process to stdout : 4574
+Child process to stdout : 4575
+Child process to stdout : 4576
+Child process to stdout : 4577
+Child process to stdout : 4578
+Child process to stdout : 4579
+Child process to stdout : 4580
+Child process to stdout : 4581
+Child process to stdout : 4582
+Child process to stdout : 4583
+Child process to stdout : 4584
+Child process to stdout : 4585
+Child process to stdout : 4586
+Child process to stdout : 4587
+Child process to stdout : 4588
+Child process to stdout : 4589
+Child process to stdout : 4590
+Child process to stdout : 4591
+Child process to stdout : 4592
+Child process to stdout : 4593
+Child process to stdout : 4594
+Child process to stdout : 4595
+Child process to stdout : 4596
+Child process to stdout : 4597
+Child process to stdout : 4598
+Child process to stdout : 4599
+Child process to stdout : 4600
+Child process to stdout : 4601
+Child process to stdout : 4602
+Child process to stdout : 4603
+Child process to stdout : 4604
+Child process to stdout : 4605
+Child process to stdout : 4606
+Child process to stdout : 4607
+Child process to stdout : 4608
+Child process to stdout : 4609
+Child process to stdout : 4610
+Child process to stdout : 4611
+Child process to stdout : 4612
+Child process to stdout : 4613
+Child process to stdout : 4614
+Child process to stdout : 4615
+Child process to stdout : 4616
+Child process to stdout : 4617
+Child process to stdout : 4618
+Child process to stdout : 4619
+Child process to stdout : 4620
+Child process to stdout : 4621
+Child process to stdout : 4622
+Child process to stdout : 4623
+Child process to stdout : 4624
+Child process to stdout : 4625
+Child process to stdout : 4626
+Child process to stdout : 4627
+Child process to stdout : 4628
+Child process to stdout : 4629
+Child process to stdout : 4630
+Child process to stdout : 4631
+Child process to stdout : 4632
+Child process to stdout : 4633
+Child process to stdout : 4634
+Child process to stdout : 4635
+Child process to stdout : 4636
+Child process to stdout : 4637
+Child process to stdout : 4638
+Child process to stdout : 4639
+Child process to stdout : 4640
+Child process to stdout : 4641
+Child process to stdout : 4642
+Child process to stdout : 4643
+Child process to stdout : 4644
+Child process to stdout : 4645
+Child process to stdout : 4646
+Child process to stdout : 4647
+Child process to stdout : 4648
+Child process to stdout : 4649
+Child process to stdout : 4650
+Child process to stdout : 4651
+Child process to stdout : 4652
+Child process to stdout : 4653
+Child process to stdout : 4654
+Child process to stdout : 4655
+Child process to stdout : 4656
+Child process to stdout : 4657
+Child process to stdout : 4658
+Child process to stdout : 4659
+Child process to stdout : 4660
+Child process to stdout : 4661
+Child process to stdout : 4662
+Child process to stdout : 4663
+Child process to stdout : 4664
+Child process to stdout : 4665
+Child process to stdout : 4666
+Child process to stdout : 4667
+Child process to stdout : 4668
+Child process to stdout : 4669
+Child process to stdout : 4670
+Child process to stdout : 4671
+Child process to stdout : 4672
+Child process to stdout : 4673
+Child process to stdout : 4674
+Child process to stdout : 4675
+Child process to stdout : 4676
+Child process to stdout : 4677
+Child process to stdout : 4678
+Child process to stdout : 4679
+Child process to stdout : 4680
+Child process to stdout : 4681
+Child process to stdout : 4682
+Child process to stdout : 4683
+Child process to stdout : 4684
+Child process to stdout : 4685
+Child process to stdout : 4686
+Child process to stdout : 4687
+Child process to stdout : 4688
+Child process to stdout : 4689
+Child process to stdout : 4690
+Child process to stdout : 4691
+Child process to stdout : 4692
+Child process to stdout : 4693
+Child process to stdout : 4694
+Child process to stdout : 4695
+Child process to stdout : 4696
+Child process to stdout : 4697
+Child process to stdout : 4698
+Child process to stdout : 4699
+Child process to stdout : 4700
+Child process to stdout : 4701
+Child process to stdout : 4702
+Child process to stdout : 4703
+Child process to stdout : 4704
+Child process to stdout : 4705
+Child process to stdout : 4706
+Child process to stdout : 4707
+Child process to stdout : 4708
+Child process to stdout : 4709
+Child process to stdout : 4710
+Child process to stdout : 4711
+Child process to stdout : 4712
+Child process to stdout : 4713
+Child process to stdout : 4714
+Child process to stdout : 4715
+Child process to stdout : 4716
+Child process to stdout : 4717
+Child process to stdout : 4718
+Child process to stdout : 4719
+Child process to stdout : 4720
+Child process to stdout : 4721
+Child process to stdout : 4722
+Child process to stdout : 4723
+Child process to stdout : 4724
+Child process to stdout : 4725
+Child process to stdout : 4726
+Child process to stdout : 4727
+Child process to stdout : 4728
+Child process to stdout : 4729
+Child process to stdout : 4730
+Child process to stdout : 4731
+Child process to stdout : 4732
+Child process to stdout : 4733
+Child process to stdout : 4734
+Child process to stdout : 4735
+Child process to stdout : 4736
+Child process to stdout : 4737
+Child process to stdout : 4738
+Child process to stdout : 4739
+Child process to stdout : 4740
+Child process to stdout : 4741
+Child process to stdout : 4742
+Child process to stdout : 4743
+Child process to stdout : 4744
+Child process to stdout : 4745
+Child process to stdout : 4746
+Child process to stdout : 4747
+Child process to stdout : 4748
+Child process to stdout : 4749
+Child process to stdout : 4750
+Child process to stdout : 4751
+Child process to stdout : 4752
+Child process to stdout : 4753
+Child process to stdout : 4754
+Child process to stdout : 4755
+Child process to stdout : 4756
+Child process to stdout : 4757
+Child process to stdout : 4758
+Child process to stdout : 4759
+Child process to stdout : 4760
+Child process to stdout : 4761
+Child process to stdout : 4762
+Child process to stdout : 4763
+Child process to stdout : 4764
+Child process to stdout : 4765
+Child process to stdout : 4766
+Child process to stdout : 4767
+Child process to stdout : 4768
+Child process to stdout : 4769
+Child process to stdout : 4770
+Child process to stdout : 4771
+Child process to stdout : 4772
+Child process to stdout : 4773
+Child process to stdout : 4774
+Child process to stdout : 4775
+Child process to stdout : 4776
+Child process to stdout : 4777
+Child process to stdout : 4778
+Child process to stdout : 4779
+Child process to stdout : 4780
+Child process to stdout : 4781
+Child process to stdout : 4782
+Child process to stdout : 4783
+Child process to stdout : 4784
+Child process to stdout : 4785
+Child process to stdout : 4786
+Child process to stdout : 4787
+Child process to stdout : 4788
+Child process to stdout : 4789
+Child process to stdout : 4790
+Child process to stdout : 4791
+Child process to stdout : 4792
+Child process to stdout : 4793
+Child process to stdout : 4794
+Child process to stdout : 4795
+Child process to stdout : 4796
+Child process to stdout : 4797
+Child process to stdout : 4798
+Child process to stdout : 4799
+Child process to stdout : 4800
+Child process to stdout : 4801
+Child process to stdout : 4802
+Child process to stdout : 4803
+Child process to stdout : 4804
+Child process to stdout : 4805
+Child process to stdout : 4806
+Child process to stdout : 4807
+Child process to stdout : 4808
+Child process to stdout : 4809
+Child process to stdout : 4810
+Child process to stdout : 4811
+Child process to stdout : 4812
+Child process to stdout : 4813
+Child process to stdout : 4814
+Child process to stdout : 4815
+Child process to stdout : 4816
+Child process to stdout : 4817
+Child process to stdout : 4818
+Child process to stdout : 4819
+Child process to stdout : 4820
+Child process to stdout : 4821
+Child process to stdout : 4822
+Child process to stdout : 4823
+Child process to stdout : 4824
+Child process to stdout : 4825
+Child process to stdout : 4826
+Child process to stdout : 4827
+Child process to stdout : 4828
+Child process to stdout : 4829
+Child process to stdout : 4830
+Child process to stdout : 4831
+Child process to stdout : 4832
+Child process to stdout : 4833
+Child process to stdout : 4834
+Child process to stdout : 4835
+Child process to stdout : 4836
+Child process to stdout : 4837
+Child process to stdout : 4838
+Child process to stdout : 4839
+Child process to stdout : 4840
+Child process to stdout : 4841
+Child process to stdout : 4842
+Child process to stdout : 4843
+Child process to stdout : 4844
+Child process to stdout : 4845
+Child process to stdout : 4846
+Child process to stdout : 4847
+Child process to stdout : 4848
+Child process to stdout : 4849
+Child process to stdout : 4850
+Child process to stdout : 4851
+Child process to stdout : 4852
+Child process to stdout : 4853
+Child process to stdout : 4854
+Child process to stdout : 4855
+Child process to stdout : 4856
+Child process to stdout : 4857
+Child process to stdout : 4858
+Child process to stdout : 4859
+Child process to stdout : 4860
+Child process to stdout : 4861
+Child process to stdout : 4862
+Child process to stdout : 4863
+Child process to stdout : 4864
+Child process to stdout : 4865
+Child process to stdout : 4866
+Child process to stdout : 4867
+Child process to stdout : 4868
+Child process to stdout : 4869
+Child process to stdout : 4870
+Child process to stdout : 4871
+Child process to stdout : 4872
+Child process to stdout : 4873
+Child process to stdout : 4874
+Child process to stdout : 4875
+Child process to stdout : 4876
+Child process to stdout : 4877
+Child process to stdout : 4878
+Child process to stdout : 4879
+Child process to stdout : 4880
+Child process to stdout : 4881
+Child process to stdout : 4882
+Child process to stdout : 4883
+Child process to stdout : 4884
+Child process to stdout : 4885
+Child process to stdout : 4886
+Child process to stdout : 4887
+Child process to stdout : 4888
+Child process to stdout : 4889
+Child process to stdout : 4890
+Child process to stdout : 4891
+Child process to stdout : 4892
+Child process to stdout : 4893
+Child process to stdout : 4894
+Child process to stdout : 4895
+Child process to stdout : 4896
+Child process to stdout : 4897
+Child process to stdout : 4898
+Child process to stdout : 4899
+Child process to stdout : 4900
+Child process to stdout : 4901
+Child process to stdout : 4902
+Child process to stdout : 4903
+Child process to stdout : 4904
+Child process to stdout : 4905
+Child process to stdout : 4906
+Child process to stdout : 4907
+Child process to stdout : 4908
+Child process to stdout : 4909
+Child process to stdout : 4910
+Child process to stdout : 4911
+Child process to stdout : 4912
+Child process to stdout : 4913
+Child process to stdout : 4914
+Child process to stdout : 4915
+Child process to stdout : 4916
+Child process to stdout : 4917
+Child process to stdout : 4918
+Child process to stdout : 4919
+Child process to stdout : 4920
+Child process to stdout : 4921
+Child process to stdout : 4922
+Child process to stdout : 4923
+Child process to stdout : 4924
+Child process to stdout : 4925
+Child process to stdout : 4926
+Child process to stdout : 4927
+Child process to stdout : 4928
+Child process to stdout : 4929
+Child process to stdout : 4930
+Child process to stdout : 4931
+Child process to stdout : 4932
+Child process to stdout : 4933
+Child process to stdout : 4934
+Child process to stdout : 4935
+Child process to stdout : 4936
+Child process to stdout : 4937
+Child process to stdout : 4938
+Child process to stdout : 4939
+Child process to stdout : 4940
+Child process to stdout : 4941
+Child process to stdout : 4942
+Child process to stdout : 4943
+Child process to stdout : 4944
+Child process to stdout : 4945
+Child process to stdout : 4946
+Child process to stdout : 4947
+Child process to stdout : 4948
+Child process to stdout : 4949
+Child process to stdout : 4950
+Child process to stdout : 4951
+Child process to stdout : 4952
+Child process to stdout : 4953
+Child process to stdout : 4954
+Child process to stdout : 4955
+Child process to stdout : 4956
+Child process to stdout : 4957
+Child process to stdout : 4958
+Child process to stdout : 4959
+Child process to stdout : 4960
+Child process to stdout : 4961
+Child process to stdout : 4962
+Child process to stdout : 4963
+Child process to stdout : 4964
+Child process to stdout : 4965
+Child process to stdout : 4966
+Child process to stdout : 4967
+Child process to stdout : 4968
+Child process to stdout : 4969
+Child process to stdout : 4970
+Child process to stdout : 4971
+Child process to stdout : 4972
+Child process to stdout : 4973
+Child process to stdout : 4974
+Child process to stdout : 4975
+Child process to stdout : 4976
+Child process to stdout : 4977
+Child process to stdout : 4978
+Child process to stdout : 4979
+Child process to stdout : 4980
+Child process to stdout : 4981
+Child process to stdout : 4982
+Child process to stdout : 4983
+Child process to stdout : 4984
+Child process to stdout : 4985
+Child process to stdout : 4986
+Child process to stdout : 4987
+Child process to stdout : 4988
+Child process to stdout : 4989
+Child process to stdout : 4990
+Child process to stdout : 4991
+Child process to stdout : 4992
+Child process to stdout : 4993
+Child process to stdout : 4994
+Child process to stdout : 4995
+Child process to stdout : 4996
+Child process to stdout : 4997
+Child process to stdout : 4998
+Child process to stdout : 4999
+Child process to stdout : 5000
+Child process to stdout : 5001
+Child process to stdout : 5002
+Child process to stdout : 5003
+Child process to stdout : 5004
+Child process to stdout : 5005
+Child process to stdout : 5006
+Child process to stdout : 5007
+Child process to stdout : 5008
+Child process to stdout : 5009
+Child process to stdout : 5010
+Child process to stdout : 5011
+Child process to stdout : 5012
+Child process to stdout : 5013
+Child process to stdout : 5014
+Child process to stdout : 5015
+Child process to stdout : 5016
+Child process to stdout : 5017
+Child process to stdout : 5018
+Child process to stdout : 5019
+Child process to stdout : 5020
+Child process to stdout : 5021
+Child process to stdout : 5022
+Child process to stdout : 5023
+Child process to stdout : 5024
+Child process to stdout : 5025
+Child process to stdout : 5026
+Child process to stdout : 5027
+Child process to stdout : 5028
+Child process to stdout : 5029
+Child process to stdout : 5030
+Child process to stdout : 5031
+Child process to stdout : 5032
+Child process to stdout : 5033
+Child process to stdout : 5034
+Child process to stdout : 5035
+Child process to stdout : 5036
+Child process to stdout : 5037
+Child process to stdout : 5038
+Child process to stdout : 5039
+Child process to stdout : 5040
+Child process to stdout : 5041
+Child process to stdout : 5042
+Child process to stdout : 5043
+Child process to stdout : 5044
+Child process to stdout : 5045
+Child process to stdout : 5046
+Child process to stdout : 5047
+Child process to stdout : 5048
+Child process to stdout : 5049
+Child process to stdout : 5050
+Child process to stdout : 5051
+Child process to stdout : 5052
+Child process to stdout : 5053
+Child process to stdout : 5054
+Child process to stdout : 5055
+Child process to stdout : 5056
+Child process to stdout : 5057
+Child process to stdout : 5058
+Child process to stdout : 5059
+Child process to stdout : 5060
+Child process to stdout : 5061
+Child process to stdout : 5062
+Child process to stdout : 5063
+Child process to stdout : 5064
+Child process to stdout : 5065
+Child process to stdout : 5066
+Child process to stdout : 5067
+Child process to stdout : 5068
+Child process to stdout : 5069
+Child process to stdout : 5070
+Child process to stdout : 5071
+Child process to stdout : 5072
+Child process to stdout : 5073
+Child process to stdout : 5074
+Child process to stdout : 5075
+Child process to stdout : 5076
+Child process to stdout : 5077
+Child process to stdout : 5078
+Child process to stdout : 5079
+Child process to stdout : 5080
+Child process to stdout : 5081
+Child process to stdout : 5082
+Child process to stdout : 5083
+Child process to stdout : 5084
+Child process to stdout : 5085
+Child process to stdout : 5086
+Child process to stdout : 5087
+Child process to stdout : 5088
+Child process to stdout : 5089
+Child process to stdout : 5090
+Child process to stdout : 5091
+Child process to stdout : 5092
+Child process to stdout : 5093
+Child process to stdout : 5094
+Child process to stdout : 5095
+Child process to stdout : 5096
+Child process to stdout : 5097
+Child process to stdout : 5098
+Child process to stdout : 5099
+Child process to stdout : 5100
+Child process to stdout : 5101
+Child process to stdout : 5102
+Child process to stdout : 5103
+Child process to stdout : 5104
+Child process to stdout : 5105
+Child process to stdout : 5106
+Child process to stdout : 5107
+Child process to stdout : 5108
+Child process to stdout : 5109
+Child process to stdout : 5110
+Child process to stdout : 5111
+Child process to stdout : 5112
+Child process to stdout : 5113
+Child process to stdout : 5114
+Child process to stdout : 5115
+Child process to stdout : 5116
+Child process to stdout : 5117
+Child process to stdout : 5118
+Child process to stdout : 5119
+Child process to stdout : 5120
+Child process to stdout : 5121
+Child process to stdout : 5122
+Child process to stdout : 5123
+Child process to stdout : 5124
+Child process to stdout : 5125
+Child process to stdout : 5126
+Child process to stdout : 5127
+Child process to stdout : 5128
+Child process to stdout : 5129
+Child process to stdout : 5130
+Child process to stdout : 5131
+Child process to stdout : 5132
+Child process to stdout : 5133
+Child process to stdout : 5134
+Child process to stdout : 5135
+Child process to stdout : 5136
+Child process to stdout : 5137
+Child process to stdout : 5138
+Child process to stdout : 5139
+Child process to stdout : 5140
+Child process to stdout : 5141
+Child process to stdout : 5142
+Child process to stdout : 5143
+Child process to stdout : 5144
+Child process to stdout : 5145
+Child process to stdout : 5146
+Child process to stdout : 5147
+Child process to stdout : 5148
+Child process to stdout : 5149
+Child process to stdout : 5150
+Child process to stdout : 5151
+Child process to stdout : 5152
+Child process to stdout : 5153
+Child process to stdout : 5154
+Child process to stdout : 5155
+Child process to stdout : 5156
+Child process to stdout : 5157
+Child process to stdout : 5158
+Child process to stdout : 5159
+Child process to stdout : 5160
+Child process to stdout : 5161
+Child process to stdout : 5162
+Child process to stdout : 5163
+Child process to stdout : 5164
+Child process to stdout : 5165
+Child process to stdout : 5166
+Child process to stdout : 5167
+Child process to stdout : 5168
+Child process to stdout : 5169
+Child process to stdout : 5170
+Child process to stdout : 5171
+Child process to stdout : 5172
+Child process to stdout : 5173
+Child process to stdout : 5174
+Child process to stdout : 5175
+Child process to stdout : 5176
+Child process to stdout : 5177
+Child process to stdout : 5178
+Child process to stdout : 5179
+Child process to stdout : 5180
+Child process to stdout : 5181
+Child process to stdout : 5182
+Child process to stdout : 5183
+Child process to stdout : 5184
+Child process to stdout : 5185
+Child process to stdout : 5186
+Child process to stdout : 5187
+Child process to stdout : 5188
+Child process to stdout : 5189
+Child process to stdout : 5190
+Child process to stdout : 5191
+Child process to stdout : 5192
+Child process to stdout : 5193
+Child process to stdout : 5194
+Child process to stdout : 5195
+Child process to stdout : 5196
+Child process to stdout : 5197
+Child process to stdout : 5198
+Child process to stdout : 5199
+Child process to stdout : 5200
+Child process to stdout : 5201
+Child process to stdout : 5202
+Child process to stdout : 5203
+Child process to stdout : 5204
+Child process to stdout : 5205
+Child process to stdout : 5206
+Child process to stdout : 5207
+Child process to stdout : 5208
+Child process to stdout : 5209
+Child process to stdout : 5210
+Child process to stdout : 5211
+Child process to stdout : 5212
+Child process to stdout : 5213
+Child process to stdout : 5214
+Child process to stdout : 5215
+Child process to stdout : 5216
+Child process to stdout : 5217
+Child process to stdout : 5218
+Child process to stdout : 5219
+Child process to stdout : 5220
+Child process to stdout : 5221
+Child process to stdout : 5222
+Child process to stdout : 5223
+Child process to stdout : 5224
+Child process to stdout : 5225
+Child process to stdout : 5226
+Child process to stdout : 5227
+Child process to stdout : 5228
+Child process to stdout : 5229
+Child process to stdout : 5230
+Child process to stdout : 5231
+Child process to stdout : 5232
+Child process to stdout : 5233
+Child process to stdout : 5234
+Child process to stdout : 5235
+Child process to stdout : 5236
+Child process to stdout : 5237
+Child process to stdout : 5238
+Child process to stdout : 5239
+Child process to stdout : 5240
+Child process to stdout : 5241
+Child process to stdout : 5242
+Child process to stdout : 5243
+Child process to stdout : 5244
+Child process to stdout : 5245
+Child process to stdout : 5246
+Child process to stdout : 5247
+Child process to stdout : 5248
+Child process to stdout : 5249
+Child process to stdout : 5250
+Child process to stdout : 5251
+Child process to stdout : 5252
+Child process to stdout : 5253
+Child process to stdout : 5254
+Child process to stdout : 5255
+Child process to stdout : 5256
+Child process to stdout : 5257
+Child process to stdout : 5258
+Child process to stdout : 5259
+Child process to stdout : 5260
+Child process to stdout : 5261
+Child process to stdout : 5262
+Child process to stdout : 5263
+Child process to stdout : 5264
+Child process to stdout : 5265
+Child process to stdout : 5266
+Child process to stdout : 5267
+Child process to stdout : 5268
+Child process to stdout : 5269
+Child process to stdout : 5270
+Child process to stdout : 5271
+Child process to stdout : 5272
+Child process to stdout : 5273
+Child process to stdout : 5274
+Child process to stdout : 5275
+Child process to stdout : 5276
+Child process to stdout : 5277
+Child process to stdout : 5278
+Child process to stdout : 5279
+Child process to stdout : 5280
+Child process to stdout : 5281
+Child process to stdout : 5282
+Child process to stdout : 5283
+Child process to stdout : 5284
+Child process to stdout : 5285
+Child process to stdout : 5286
+Child process to stdout : 5287
+Child process to stdout : 5288
+Child process to stdout : 5289
+Child process to stdout : 5290
+Child process to stdout : 5291
+Child process to stdout : 5292
+Child process to stdout : 5293
+Child process to stdout : 5294
+Child process to stdout : 5295
+Child process to stdout : 5296
+Child process to stdout : 5297
+Child process to stdout : 5298
+Child process to stdout : 5299
+Child process to stdout : 5300
+Child process to stdout : 5301
+Child process to stdout : 5302
+Child process to stdout : 5303
+Child process to stdout : 5304
+Child process to stdout : 5305
+Child process to stdout : 5306
+Child process to stdout : 5307
+Child process to stdout : 5308
+Child process to stdout : 5309
+Child process to stdout : 5310
+Child process to stdout : 5311
+Child process to stdout : 5312
+Child process to stdout : 5313
+Child process to stdout : 5314
+Child process to stdout : 5315
+Child process to stdout : 5316
+Child process to stdout : 5317
+Child process to stdout : 5318
+Child process to stdout : 5319
+Child process to stdout : 5320
+Child process to stdout : 5321
+Child process to stdout : 5322
+Child process to stdout : 5323
+Child process to stdout : 5324
+Child process to stdout : 5325
+Child process to stdout : 5326
+Child process to stdout : 5327
+Child process to stdout : 5328
+Child process to stdout : 5329
+Child process to stdout : 5330
+Child process to stdout : 5331
+Child process to stdout : 5332
+Child process to stdout : 5333
+Child process to stdout : 5334
+Child process to stdout : 5335
+Child process to stdout : 5336
+Child process to stdout : 5337
+Child process to stdout : 5338
+Child process to stdout : 5339
+Child process to stdout : 5340
+Child process to stdout : 5341
+Child process to stdout : 5342
+Child process to stdout : 5343
+Child process to stdout : 5344
+Child process to stdout : 5345
+Child process to stdout : 5346
+Child process to stdout : 5347
+Child process to stdout : 5348
+Child process to stdout : 5349
+Child process to stdout : 5350
+Child process to stdout : 5351
+Child process to stdout : 5352
+Child process to stdout : 5353
+Child process to stdout : 5354
+Child process to stdout : 5355
+Child process to stdout : 5356
+Child process to stdout : 5357
+Child process to stdout : 5358
+Child process to stdout : 5359
+Child process to stdout : 5360
+Child process to stdout : 5361
+Child process to stdout : 5362
+Child process to stdout : 5363
+Child process to stdout : 5364
+Child process to stdout : 5365
+Child process to stdout : 5366
+Child process to stdout : 5367
+Child process to stdout : 5368
+Child process to stdout : 5369
+Child process to stdout : 5370
+Child process to stdout : 5371
+Child process to stdout : 5372
+Child process to stdout : 5373
+Child process to stdout : 5374
+Child process to stdout : 5375
+Child process to stdout : 5376
+Child process to stdout : 5377
+Child process to stdout : 5378
+Child process to stdout : 5379
+Child process to stdout : 5380
+Child process to stdout : 5381
+Child process to stdout : 5382
+Child process to stdout : 5383
+Child process to stdout : 5384
+Child process to stdout : 5385
+Child process to stdout : 5386
+Child process to stdout : 5387
+Child process to stdout : 5388
+Child process to stdout : 5389
+Child process to stdout : 5390
+Child process to stdout : 5391
+Child process to stdout : 5392
+Child process to stdout : 5393
+Child process to stdout : 5394
+Child process to stdout : 5395
+Child process to stdout : 5396
+Child process to stdout : 5397
+Child process to stdout : 5398
+Child process to stdout : 5399
+Child process to stdout : 5400
+Child process to stdout : 5401
+Child process to stdout : 5402
+Child process to stdout : 5403
+Child process to stdout : 5404
+Child process to stdout : 5405
+Child process to stdout : 5406
+Child process to stdout : 5407
+Child process to stdout : 5408
+Child process to stdout : 5409
+Child process to stdout : 5410
+Child process to stdout : 5411
+Child process to stdout : 5412
+Child process to stdout : 5413
+Child process to stdout : 5414
+Child process to stdout : 5415
+Child process to stdout : 5416
+Child process to stdout : 5417
+Child process to stdout : 5418
+Child process to stdout : 5419
+Child process to stdout : 5420
+Child process to stdout : 5421
+Child process to stdout : 5422
+Child process to stdout : 5423
+Child process to stdout : 5424
+Child process to stdout : 5425
+Child process to stdout : 5426
+Child process to stdout : 5427
+Child process to stdout : 5428
+Child process to stdout : 5429
+Child process to stdout : 5430
+Child process to stdout : 5431
+Child process to stdout : 5432
+Child process to stdout : 5433
+Child process to stdout : 5434
+Child process to stdout : 5435
+Child process to stdout : 5436
+Child process to stdout : 5437
+Child process to stdout : 5438
+Child process to stdout : 5439
+Child process to stdout : 5440
+Child process to stdout : 5441
+Child process to stdout : 5442
+Child process to stdout : 5443
+Child process to stdout : 5444
+Child process to stdout : 5445
+Child process to stdout : 5446
+Child process to stdout : 5447
+Child process to stdout : 5448
+Child process to stdout : 5449
+Child process to stdout : 5450
+Child process to stdout : 5451
+Child process to stdout : 5452
+Child process to stdout : 5453
+Child process to stdout : 5454
+Child process to stdout : 5455
+Child process to stdout : 5456
+Child process to stdout : 5457
+Child process to stdout : 5458
+Child process to stdout : 5459
+Child process to stdout : 5460
+Child process to stdout : 5461
+Child process to stdout : 5462
+Child process to stdout : 5463
+Child process to stdout : 5464
+Child process to stdout : 5465
+Child process to stdout : 5466
+Child process to stdout : 5467
+Child process to stdout : 5468
+Child process to stdout : 5469
+Child process to stdout : 5470
+Child process to stdout : 5471
+Child process to stdout : 5472
+Child process to stdout : 5473
+Child process to stdout : 5474
+Child process to stdout : 5475
+Child process to stdout : 5476
+Child process to stdout : 5477
+Child process to stdout : 5478
+Child process to stdout : 5479
+Child process to stdout : 5480
+Child process to stdout : 5481
+Child process to stdout : 5482
+Child process to stdout : 5483
+Child process to stdout : 5484
+Child process to stdout : 5485
+Child process to stdout : 5486
+Child process to stdout : 5487
+Child process to stdout : 5488
+Child process to stdout : 5489
+Child process to stdout : 5490
+Child process to stdout : 5491
+Child process to stdout : 5492
+Child process to stdout : 5493
+Child process to stdout : 5494
+Child process to stdout : 5495
+Child process to stdout : 5496
+Child process to stdout : 5497
+Child process to stdout : 5498
+Child process to stdout : 5499
+Child process to stdout : 5500
+Child process to stdout : 5501
+Child process to stdout : 5502
+Child process to stdout : 5503
+Child process to stdout : 5504
+Child process to stdout : 5505
+Child process to stdout : 5506
+Child process to stdout : 5507
+Child process to stdout : 5508
+Child process to stdout : 5509
+Child process to stdout : 5510
+Child process to stdout : 5511
+Child process to stdout : 5512
+Child process to stdout : 5513
+Child process to stdout : 5514
+Child process to stdout : 5515
+Child process to stdout : 5516
+Child process to stdout : 5517
+Child process to stdout : 5518
+Child process to stdout : 5519
+Child process to stdout : 5520
+Child process to stdout : 5521
+Child process to stdout : 5522
+Child process to stdout : 5523
+Child process to stdout : 5524
+Child process to stdout : 5525
+Child process to stdout : 5526
+Child process to stdout : 5527
+Child process to stdout : 5528
+Child process to stdout : 5529
+Child process to stdout : 5530
+Child process to stdout : 5531
+Child process to stdout : 5532
+Child process to stdout : 5533
+Child process to stdout : 5534
+Child process to stdout : 5535
+Child process to stdout : 5536
+Child process to stdout : 5537
+Child process to stdout : 5538
+Child process to stdout : 5539
+Child process to stdout : 5540
+Child process to stdout : 5541
+Child process to stdout : 5542
+Child process to stdout : 5543
+Child process to stdout : 5544
+Child process to stdout : 5545
+Child process to stdout : 5546
+Child process to stdout : 5547
+Child process to stdout : 5548
+Child process to stdout : 5549
+Child process to stdout : 5550
+Child process to stdout : 5551
+Child process to stdout : 5552
+Child process to stdout : 5553
+Child process to stdout : 5554
+Child process to stdout : 5555
+Child process to stdout : 5556
+Child process to stdout : 5557
+Child process to stdout : 5558
+Child process to stdout : 5559
+Child process to stdout : 5560
+Child process to stdout : 5561
+Child process to stdout : 5562
+Child process to stdout : 5563
+Child process to stdout : 5564
+Child process to stdout : 5565
+Child process to stdout : 5566
+Child process to stdout : 5567
+Child process to stdout : 5568
+Child process to stdout : 5569
+Child process to stdout : 5570
+Child process to stdout : 5571
+Child process to stdout : 5572
+Child process to stdout : 5573
+Child process to stdout : 5574
+Child process to stdout : 5575
+Child process to stdout : 5576
+Child process to stdout : 5577
+Child process to stdout : 5578
+Child process to stdout : 5579
+Child process to stdout : 5580
+Child process to stdout : 5581
+Child process to stdout : 5582
+Child process to stdout : 5583
+Child process to stdout : 5584
+Child process to stdout : 5585
+Child process to stdout : 5586
+Child process to stdout : 5587
+Child process to stdout : 5588
+Child process to stdout : 5589
+Child process to stdout : 5590
+Child process to stdout : 5591
+Child process to stdout : 5592
+Child process to stdout : 5593
+Child process to stdout : 5594
+Child process to stdout : 5595
+Child process to stdout : 5596
+Child process to stdout : 5597
+Child process to stdout : 5598
+Child process to stdout : 5599
+Child process to stdout : 5600
+Child process to stdout : 5601
+Child process to stdout : 5602
+Child process to stdout : 5603
+Child process to stdout : 5604
+Child process to stdout : 5605
+Child process to stdout : 5606
+Child process to stdout : 5607
+Child process to stdout : 5608
+Child process to stdout : 5609
+Child process to stdout : 5610
+Child process to stdout : 5611
+Child process to stdout : 5612
+Child process to stdout : 5613
+Child process to stdout : 5614
+Child process to stdout : 5615
+Child process to stdout : 5616
+Child process to stdout : 5617
+Child process to stdout : 5618
+Child process to stdout : 5619
+Child process to stdout : 5620
+Child process to stdout : 5621
+Child process to stdout : 5622
+Child process to stdout : 5623
+Child process to stdout : 5624
+Child process to stdout : 5625
+Child process to stdout : 5626
+Child process to stdout : 5627
+Child process to stdout : 5628
+Child process to stdout : 5629
+Child process to stdout : 5630
+Child process to stdout : 5631
+Child process to stdout : 5632
+Child process to stdout : 5633
+Child process to stdout : 5634
+Child process to stdout : 5635
+Child process to stdout : 5636
+Child process to stdout : 5637
+Child process to stdout : 5638
+Child process to stdout : 5639
+Child process to stdout : 5640
+Child process to stdout : 5641
+Child process to stdout : 5642
+Child process to stdout : 5643
+Child process to stdout : 5644
+Child process to stdout : 5645
+Child process to stdout : 5646
+Child process to stdout : 5647
+Child process to stdout : 5648
+Child process to stdout : 5649
+Child process to stdout : 5650
+Child process to stdout : 5651
+Child process to stdout : 5652
+Child process to stdout : 5653
+Child process to stdout : 5654
+Child process to stdout : 5655
+Child process to stdout : 5656
+Child process to stdout : 5657
+Child process to stdout : 5658
+Child process to stdout : 5659
+Child process to stdout : 5660
+Child process to stdout : 5661
+Child process to stdout : 5662
+Child process to stdout : 5663
+Child process to stdout : 5664
+Child process to stdout : 5665
+Child process to stdout : 5666
+Child process to stdout : 5667
+Child process to stdout : 5668
+Child process to stdout : 5669
+Child process to stdout : 5670
+Child process to stdout : 5671
+Child process to stdout : 5672
+Child process to stdout : 5673
+Child process to stdout : 5674
+Child process to stdout : 5675
+Child process to stdout : 5676
+Child process to stdout : 5677
+Child process to stdout : 5678
+Child process to stdout : 5679
+Child process to stdout : 5680
+Child process to stdout : 5681
+Child process to stdout : 5682
+Child process to stdout : 5683
+Child process to stdout : 5684
+Child process to stdout : 5685
+Child process to stdout : 5686
+Child process to stdout : 5687
+Child process to stdout : 5688
+Child process to stdout : 5689
+Child process to stdout : 5690
+Child process to stdout : 5691
+Child process to stdout : 5692
+Child process to stdout : 5693
+Child process to stdout : 5694
+Child process to stdout : 5695
+Child process to stdout : 5696
+Child process to stdout : 5697
+Child process to stdout : 5698
+Child process to stdout : 5699
+Child process to stdout : 5700
+Child process to stdout : 5701
+Child process to stdout : 5702
+Child process to stdout : 5703
+Child process to stdout : 5704
+Child process to stdout : 5705
+Child process to stdout : 5706
+Child process to stdout : 5707
+Child process to stdout : 5708
+Child process to stdout : 5709
+Child process to stdout : 5710
+Child process to stdout : 5711
+Child process to stdout : 5712
+Child process to stdout : 5713
+Child process to stdout : 5714
+Child process to stdout : 5715
+Child process to stdout : 5716
+Child process to stdout : 5717
+Child process to stdout : 5718
+Child process to stdout : 5719
+Child process to stdout : 5720
+Child process to stdout : 5721
+Child process to stdout : 5722
+Child process to stdout : 5723
+Child process to stdout : 5724
+Child process to stdout : 5725
+Child process to stdout : 5726
+Child process to stdout : 5727
+Child process to stdout : 5728
+Child process to stdout : 5729
+Child process to stdout : 5730
+Child process to stdout : 5731
+Child process to stdout : 5732
+Child process to stdout : 5733
+Child process to stdout : 5734
+Child process to stdout : 5735
+Child process to stdout : 5736
+Child process to stdout : 5737
+Child process to stdout : 5738
+Child process to stdout : 5739
+Child process to stdout : 5740
+Child process to stdout : 5741
+Child process to stdout : 5742
+Child process to stdout : 5743
+Child process to stdout : 5744
+Child process to stdout : 5745
+Child process to stdout : 5746
+Child process to stdout : 5747
+Child process to stdout : 5748
+Child process to stdout : 5749
+Child process to stdout : 5750
+Child process to stdout : 5751
+Child process to stdout : 5752
+Child process to stdout : 5753
+Child process to stdout : 5754
+Child process to stdout : 5755
+Child process to stdout : 5756
+Child process to stdout : 5757
+Child process to stdout : 5758
+Child process to stdout : 5759
+Child process to stdout : 5760
+Child process to stdout : 5761
+Child process to stdout : 5762
+Child process to stdout : 5763
+Child process to stdout : 5764
+Child process to stdout : 5765
+Child process to stdout : 5766
+Child process to stdout : 5767
+Child process to stdout : 5768
+Child process to stdout : 5769
+Child process to stdout : 5770
+Child process to stdout : 5771
+Child process to stdout : 5772
+Child process to stdout : 5773
+Child process to stdout : 5774
+Child process to stdout : 5775
+Child process to stdout : 5776
+Child process to stdout : 5777
+Child process to stdout : 5778
+Child process to stdout : 5779
+Child process to stdout : 5780
+Child process to stdout : 5781
+Child process to stdout : 5782
+Child process to stdout : 5783
+Child process to stdout : 5784
+Child process to stdout : 5785
+Child process to stdout : 5786
+Child process to stdout : 5787
+Child process to stdout : 5788
+Child process to stdout : 5789
+Child process to stdout : 5790
+Child process to stdout : 5791
+Child process to stdout : 5792
+Child process to stdout : 5793
+Child process to stdout : 5794
+Child process to stdout : 5795
+Child process to stdout : 5796
+Child process to stdout : 5797
+Child process to stdout : 5798
+Child process to stdout : 5799
+Child process to stdout : 5800
+Child process to stdout : 5801
+Child process to stdout : 5802
+Child process to stdout : 5803
+Child process to stdout : 5804
+Child process to stdout : 5805
+Child process to stdout : 5806
+Child process to stdout : 5807
+Child process to stdout : 5808
+Child process to stdout : 5809
+Child process to stdout : 5810
+Child process to stdout : 5811
+Child process to stdout : 5812
+Child process to stdout : 5813
+Child process to stdout : 5814
+Child process to stdout : 5815
+Child process to stdout : 5816
+Child process to stdout : 5817
+Child process to stdout : 5818
+Child process to stdout : 5819
+Child process to stdout : 5820
+Child process to stdout : 5821
+Child process to stdout : 5822
+Child process to stdout : 5823
+Child process to stdout : 5824
+Child process to stdout : 5825
+Child process to stdout : 5826
+Child process to stdout : 5827
+Child process to stdout : 5828
+Child process to stdout : 5829
+Child process to stdout : 5830
+Child process to stdout : 5831
+Child process to stdout : 5832
+Child process to stdout : 5833
+Child process to stdout : 5834
+Child process to stdout : 5835
+Child process to stdout : 5836
+Child process to stdout : 5837
+Child process to stdout : 5838
+Child process to stdout : 5839
+Child process to stdout : 5840
+Child process to stdout : 5841
+Child process to stdout : 5842
+Child process to stdout : 5843
+Child process to stdout : 5844
+Child process to stdout : 5845
+Child process to stdout : 5846
+Child process to stdout : 5847
+Child process to stdout : 5848
+Child process to stdout : 5849
+Child process to stdout : 5850
+Child process to stdout : 5851
+Child process to stdout : 5852
+Child process to stdout : 5853
+Child process to stdout : 5854
+Child process to stdout : 5855
+Child process to stdout : 5856
+Child process to stdout : 5857
+Child process to stdout : 5858
+Child process to stdout : 5859
+Child process to stdout : 5860
+Child process to stdout : 5861
+Child process to stdout : 5862
+Child process to stdout : 5863
+Child process to stdout : 5864
+Child process to stdout : 5865
+Child process to stdout : 5866
+Child process to stdout : 5867
+Child process to stdout : 5868
+Child process to stdout : 5869
+Child process to stdout : 5870
+Child process to stdout : 5871
+Child process to stdout : 5872
+Child process to stdout : 5873
+Child process to stdout : 5874
+Child process to stdout : 5875
+Child process to stdout : 5876
+Child process to stdout : 5877
+Child process to stdout : 5878
+Child process to stdout : 5879
+Child process to stdout : 5880
+Child process to stdout : 5881
+Child process to stdout : 5882
+Child process to stdout : 5883
+Child process to stdout : 5884
+Child process to stdout : 5885
+Child process to stdout : 5886
+Child process to stdout : 5887
+Child process to stdout : 5888
+Child process to stdout : 5889
+Child process to stdout : 5890
+Child process to stdout : 5891
+Child process to stdout : 5892
+Child process to stdout : 5893
+Child process to stdout : 5894
+Child process to stdout : 5895
+Child process to stdout : 5896
+Child process to stdout : 5897
+Child process to stdout : 5898
+Child process to stdout : 5899
+Child process to stdout : 5900
+Child process to stdout : 5901
+Child process to stdout : 5902
+Child process to stdout : 5903
+Child process to stdout : 5904
+Child process to stdout : 5905
+Child process to stdout : 5906
+Child process to stdout : 5907
+Child process to stdout : 5908
+Child process to stdout : 5909
+Child process to stdout : 5910
+Child process to stdout : 5911
+Child process to stdout : 5912
+Child process to stdout : 5913
+Child process to stdout : 5914
+Child process to stdout : 5915
+Child process to stdout : 5916
+Child process to stdout : 5917
+Child process to stdout : 5918
+Child process to stdout : 5919
+Child process to stdout : 5920
+Child process to stdout : 5921
+Child process to stdout : 5922
+Child process to stdout : 5923
+Child process to stdout : 5924
+Child process to stdout : 5925
+Child process to stdout : 5926
+Child process to stdout : 5927
+Child process to stdout : 5928
+Child process to stdout : 5929
+Child process to stdout : 5930
+Child process to stdout : 5931
+Child process to stdout : 5932
+Child process to stdout : 5933
+Child process to stdout : 5934
+Child process to stdout : 5935
+Child process to stdout : 5936
+Child process to stdout : 5937
+Child process to stdout : 5938
+Child process to stdout : 5939
+Child process to stdout : 5940
+Child process to stdout : 5941
+Child process to stdout : 5942
+Child process to stdout : 5943
+Child process to stdout : 5944
+Child process to stdout : 5945
+Child process to stdout : 5946
+Child process to stdout : 5947
+Child process to stdout : 5948
+Child process to stdout : 5949
+Child process to stdout : 5950
+Child process to stdout : 5951
+Child process to stdout : 5952
+Child process to stdout : 5953
+Child process to stdout : 5954
+Child process to stdout : 5955
+Child process to stdout : 5956
+Child process to stdout : 5957
+Child process to stdout : 5958
+Child process to stdout : 5959
+Child process to stdout : 5960
+Child process to stdout : 5961
+Child process to stdout : 5962
+Child process to stdout : 5963
+Child process to stdout : 5964
+Child process to stdout : 5965
+Child process to stdout : 5966
+Child process to stdout : 5967
+Child process to stdout : 5968
+Child process to stdout : 5969
+Child process to stdout : 5970
+Child process to stdout : 5971
+Child process to stdout : 5972
+Child process to stdout : 5973
+Child process to stdout : 5974
+Child process to stdout : 5975
+Child process to stdout : 5976
+Child process to stdout : 5977
+Child process to stdout : 5978
+Child process to stdout : 5979
+Child process to stdout : 5980
+Child process to stdout : 5981
+Child process to stdout : 5982
+Child process to stdout : 5983
+Child process to stdout : 5984
+Child process to stdout : 5985
+Child process to stdout : 5986
+Child process to stdout : 5987
+Child process to stdout : 5988
+Child process to stdout : 5989
+Child process to stdout : 5990
+Child process to stdout : 5991
+Child process to stdout : 5992
+Child process to stdout : 5993
+Child process to stdout : 5994
+Child process to stdout : 5995
+Child process to stdout : 5996
+Child process to stdout : 5997
+Child process to stdout : 5998
+Child process to stdout : 5999
+Child process to stdout : 6000
+Child process to stdout : 6001
+Child process to stdout : 6002
+Child process to stdout : 6003
+Child process to stdout : 6004
+Child process to stdout : 6005
+Child process to stdout : 6006
+Child process to stdout : 6007
+Child process to stdout : 6008
+Child process to stdout : 6009
+Child process to stdout : 6010
+Child process to stdout : 6011
+Child process to stdout : 6012
+Child process to stdout : 6013
+Child process to stdout : 6014
+Child process to stdout : 6015
+Child process to stdout : 6016
+Child process to stdout : 6017
+Child process to stdout : 6018
+Child process to stdout : 6019
+Child process to stdout : 6020
+Child process to stdout : 6021
+Child process to stdout : 6022
+Child process to stdout : 6023
+Child process to stdout : 6024
+Child process to stdout : 6025
+Child process to stdout : 6026
+Child process to stdout : 6027
+Child process to stdout : 6028
+Child process to stdout : 6029
+Child process to stdout : 6030
+Child process to stdout : 6031
+Child process to stdout : 6032
+Child process to stdout : 6033
+Child process to stdout : 6034
+Child process to stdout : 6035
+Child process to stdout : 6036
+Child process to stdout : 6037
+Child process to stdout : 6038
+Child process to stdout : 6039
+Child process to stdout : 6040
+Child process to stdout : 6041
+Child process to stdout : 6042
+Child process to stdout : 6043
+Child process to stdout : 6044
+Child process to stdout : 6045
+Child process to stdout : 6046
+Child process to stdout : 6047
+Child process to stdout : 6048
+Child process to stdout : 6049
+Child process to stdout : 6050
+Child process to stdout : 6051
+Child process to stdout : 6052
+Child process to stdout : 6053
+Child process to stdout : 6054
+Child process to stdout : 6055
+Child process to stdout : 6056
+Child process to stdout : 6057
+Child process to stdout : 6058
+Child process to stdout : 6059
+Child process to stdout : 6060
+Child process to stdout : 6061
+Child process to stdout : 6062
+Child process to stdout : 6063
+Child process to stdout : 6064
+Child process to stdout : 6065
+Child process to stdout : 6066
+Child process to stdout : 6067
+Child process to stdout : 6068
+Child process to stdout : 6069
+Child process to stdout : 6070
+Child process to stdout : 6071
+Child process to stdout : 6072
+Child process to stdout : 6073
+Child process to stdout : 6074
+Child process to stdout : 6075
+Child process to stdout : 6076
+Child process to stdout : 6077
+Child process to stdout : 6078
+Child process to stdout : 6079
+Child process to stdout : 6080
+Child process to stdout : 6081
+Child process to stdout : 6082
+Child process to stdout : 6083
+Child process to stdout : 6084
+Child process to stdout : 6085
+Child process to stdout : 6086
+Child process to stdout : 6087
+Child process to stdout : 6088
+Child process to stdout : 6089
+Child process to stdout : 6090
+Child process to stdout : 6091
+Child process to stdout : 6092
+Child process to stdout : 6093
+Child process to stdout : 6094
+Child process to stdout : 6095
+Child process to stdout : 6096
+Child process to stdout : 6097
+Child process to stdout : 6098
+Child process to stdout : 6099
+Child process to stdout : 6100
+Child process to stdout : 6101
+Child process to stdout : 6102
+Child process to stdout : 6103
+Child process to stdout : 6104
+Child process to stdout : 6105
+Child process to stdout : 6106
+Child process to stdout : 6107
+Child process to stdout : 6108
+Child process to stdout : 6109
+Child process to stdout : 6110
+Child process to stdout : 6111
+Child process to stdout : 6112
+Child process to stdout : 6113
+Child process to stdout : 6114
+Child process to stdout : 6115
+Child process to stdout : 6116
+Child process to stdout : 6117
+Child process to stdout : 6118
+Child process to stdout : 6119
+Child process to stdout : 6120
+Child process to stdout : 6121
+Child process to stdout : 6122
+Child process to stdout : 6123
+Child process to stdout : 6124
+Child process to stdout : 6125
+Child process to stdout : 6126
+Child process to stdout : 6127
+Child process to stdout : 6128
+Child process to stdout : 6129
+Child process to stdout : 6130
+Child process to stdout : 6131
+Child process to stdout : 6132
+Child process to stdout : 6133
+Child process to stdout : 6134
+Child process to stdout : 6135
+Child process to stdout : 6136
+Child process to stdout : 6137
+Child process to stdout : 6138
+Child process to stdout : 6139
+Child process to stdout : 6140
+Child process to stdout : 6141
+Child process to stdout : 6142
+Child process to stdout : 6143
+Child process to stdout : 6144
+Child process to stdout : 6145
+Child process to stdout : 6146
+Child process to stdout : 6147
+Child process to stdout : 6148
+Child process to stdout : 6149
+Child process to stdout : 6150
+Child process to stdout : 6151
+Child process to stdout : 6152
+Child process to stdout : 6153
+Child process to stdout : 6154
+Child process to stdout : 6155
+Child process to stdout : 6156
+Child process to stdout : 6157
+Child process to stdout : 6158
+Child process to stdout : 6159
+Child process to stdout : 6160
+Child process to stdout : 6161
+Child process to stdout : 6162
+Child process to stdout : 6163
+Child process to stdout : 6164
+Child process to stdout : 6165
+Child process to stdout : 6166
+Child process to stdout : 6167
+Child process to stdout : 6168
+Child process to stdout : 6169
+Child process to stdout : 6170
+Child process to stdout : 6171
+Child process to stdout : 6172
+Child process to stdout : 6173
+Child process to stdout : 6174
+Child process to stdout : 6175
+Child process to stdout : 6176
+Child process to stdout : 6177
+Child process to stdout : 6178
+Child process to stdout : 6179
+Child process to stdout : 6180
+Child process to stdout : 6181
+Child process to stdout : 6182
+Child process to stdout : 6183
+Child process to stdout : 6184
+Child process to stdout : 6185
+Child process to stdout : 6186
+Child process to stdout : 6187
+Child process to stdout : 6188
+Child process to stdout : 6189
+Child process to stdout : 6190
+Child process to stdout : 6191
+Child process to stdout : 6192
+Child process to stdout : 6193
+Child process to stdout : 6194
+Child process to stdout : 6195
+Child process to stdout : 6196
+Child process to stdout : 6197
+Child process to stdout : 6198
+Child process to stdout : 6199
+Child process to stdout : 6200
+Child process to stdout : 6201
+Child process to stdout : 6202
+Child process to stdout : 6203
+Child process to stdout : 6204
+Child process to stdout : 6205
+Child process to stdout : 6206
+Child process to stdout : 6207
+Child process to stdout : 6208
+Child process to stdout : 6209
+Child process to stdout : 6210
+Child process to stdout : 6211
+Child process to stdout : 6212
+Child process to stdout : 6213
+Child process to stdout : 6214
+Child process to stdout : 6215
+Child process to stdout : 6216
+Child process to stdout : 6217
+Child process to stdout : 6218
+Child process to stdout : 6219
+Child process to stdout : 6220
+Child process to stdout : 6221
+Child process to stdout : 6222
+Child process to stdout : 6223
+Child process to stdout : 6224
+Child process to stdout : 6225
+Child process to stdout : 6226
+Child process to stdout : 6227
+Child process to stdout : 6228
+Child process to stdout : 6229
+Child process to stdout : 6230
+Child process to stdout : 6231
+Child process to stdout : 6232
+Child process to stdout : 6233
+Child process to stdout : 6234
+Child process to stdout : 6235
+Child process to stdout : 6236
+Child process to stdout : 6237
+Child process to stdout : 6238
+Child process to stdout : 6239
+Child process to stdout : 6240
+Child process to stdout : 6241
+Child process to stdout : 6242
+Child process to stdout : 6243
+Child process to stdout : 6244
+Child process to stdout : 6245
+Child process to stdout : 6246
+Child process to stdout : 6247
+Child process to stdout : 6248
+Child process to stdout : 6249
+Child process to stdout : 6250
+Child process to stdout : 6251
+Child process to stdout : 6252
+Child process to stdout : 6253
+Child process to stdout : 6254
+Child process to stdout : 6255
+Child process to stdout : 6256
+Child process to stdout : 6257
+Child process to stdout : 6258
+Child process to stdout : 6259
+Child process to stdout : 6260
+Child process to stdout : 6261
+Child process to stdout : 6262
+Child process to stdout : 6263
+Child process to stdout : 6264
+Child process to stdout : 6265
+Child process to stdout : 6266
+Child process to stdout : 6267
+Child process to stdout : 6268
+Child process to stdout : 6269
+Child process to stdout : 6270
+Child process to stdout : 6271
+Child process to stdout : 6272
+Child process to stdout : 6273
+Child process to stdout : 6274
+Child process to stdout : 6275
+Child process to stdout : 6276
+Child process to stdout : 6277
+Child process to stdout : 6278
+Child process to stdout : 6279
+Child process to stdout : 6280
+Child process to stdout : 6281
+Child process to stdout : 6282
+Child process to stdout : 6283
+Child process to stdout : 6284
+Child process to stdout : 6285
+Child process to stdout : 6286
+Child process to stdout : 6287
+Child process to stdout : 6288
+Child process to stdout : 6289
+Child process to stdout : 6290
+Child process to stdout : 6291
+Child process to stdout : 6292
+Child process to stdout : 6293
+Child process to stdout : 6294
+Child process to stdout : 6295
+Child process to stdout : 6296
+Child process to stdout : 6297
+Child process to stdout : 6298
+Child process to stdout : 6299
+Child process to stdout : 6300
+Child process to stdout : 6301
+Child process to stdout : 6302
+Child process to stdout : 6303
+Child process to stdout : 6304
+Child process to stdout : 6305
+Child process to stdout : 6306
+Child process to stdout : 6307
+Child process to stdout : 6308
+Child process to stdout : 6309
+Child process to stdout : 6310
+Child process to stdout : 6311
+Child process to stdout : 6312
+Child process to stdout : 6313
+Child process to stdout : 6314
+Child process to stdout : 6315
+Child process to stdout : 6316
+Child process to stdout : 6317
+Child process to stdout : 6318
+Child process to stdout : 6319
+Child process to stdout : 6320
+Child process to stdout : 6321
+Child process to stdout : 6322
+Child process to stdout : 6323
+Child process to stdout : 6324
+Child process to stdout : 6325
+Child process to stdout : 6326
+Child process to stdout : 6327
+Child process to stdout : 6328
+Child process to stdout : 6329
+Child process to stdout : 6330
+Child process to stdout : 6331
+Child process to stdout : 6332
+Child process to stdout : 6333
+Child process to stdout : 6334
+Child process to stdout : 6335
+Child process to stdout : 6336
+Child process to stdout : 6337
+Child process to stdout : 6338
+Child process to stdout : 6339
+Child process to stdout : 6340
+Child process to stdout : 6341
+Child process to stdout : 6342
+Child process to stdout : 6343
+Child process to stdout : 6344
+Child process to stdout : 6345
+Child process to stdout : 6346
+Child process to stdout : 6347
+Child process to stdout : 6348
+Child process to stdout : 6349
+Child process to stdout : 6350
+Child process to stdout : 6351
+Child process to stdout : 6352
+Child process to stdout : 6353
+Child process to stdout : 6354
+Child process to stdout : 6355
+Child process to stdout : 6356
+Child process to stdout : 6357
+Child process to stdout : 6358
+Child process to stdout : 6359
+Child process to stdout : 6360
+Child process to stdout : 6361
+Child process to stdout : 6362
+Child process to stdout : 6363
+Child process to stdout : 6364
+Child process to stdout : 6365
+Child process to stdout : 6366
+Child process to stdout : 6367
+Child process to stdout : 6368
+Child process to stdout : 6369
+Child process to stdout : 6370
+Child process to stdout : 6371
+Child process to stdout : 6372
+Child process to stdout : 6373
+Child process to stdout : 6374
+Child process to stdout : 6375
+Child process to stdout : 6376
+Child process to stdout : 6377
+Child process to stdout : 6378
+Child process to stdout : 6379
+Child process to stdout : 6380
+Child process to stdout : 6381
+Child process to stdout : 6382
+Child process to stdout : 6383
+Child process to stdout : 6384
+Child process to stdout : 6385
+Child process to stdout : 6386
+Child process to stdout : 6387
+Child process to stdout : 6388
+Child process to stdout : 6389
+Child process to stdout : 6390
+Child process to stdout : 6391
+Child process to stdout : 6392
+Child process to stdout : 6393
+Child process to stdout : 6394
+Child process to stdout : 6395
+Child process to stdout : 6396
+Child process to stdout : 6397
+Child process to stdout : 6398
+Child process to stdout : 6399
+Child process to stdout : 6400
+Child process to stdout : 6401
+Child process to stdout : 6402
+Child process to stdout : 6403
+Child process to stdout : 6404
+Child process to stdout : 6405
+Child process to stdout : 6406
+Child process to stdout : 6407
+Child process to stdout : 6408
+Child process to stdout : 6409
+Child process to stdout : 6410
+Child process to stdout : 6411
+Child process to stdout : 6412
+Child process to stdout : 6413
+Child process to stdout : 6414
+Child process to stdout : 6415
+Child process to stdout : 6416
+Child process to stdout : 6417
+Child process to stdout : 6418
+Child process to stdout : 6419
+Child process to stdout : 6420
+Child process to stdout : 6421
+Child process to stdout : 6422
+Child process to stdout : 6423
+Child process to stdout : 6424
+Child process to stdout : 6425
+Child process to stdout : 6426
+Child process to stdout : 6427
+Child process to stdout : 6428
+Child process to stdout : 6429
+Child process to stdout : 6430
+Child process to stdout : 6431
+Child process to stdout : 6432
+Child process to stdout : 6433
+Child process to stdout : 6434
+Child process to stdout : 6435
+Child process to stdout : 6436
+Child process to stdout : 6437
+Child process to stdout : 6438
+Child process to stdout : 6439
+Child process to stdout : 6440
+Child process to stdout : 6441
+Child process to stdout : 6442
+Child process to stdout : 6443
+Child process to stdout : 6444
+Child process to stdout : 6445
+Child process to stdout : 6446
+Child process to stdout : 6447
+Child process to stdout : 6448
+Child process to stdout : 6449
+Child process to stdout : 6450
+Child process to stdout : 6451
+Child process to stdout : 6452
+Child process to stdout : 6453
+Child process to stdout : 6454
+Child process to stdout : 6455
+Child process to stdout : 6456
+Child process to stdout : 6457
+Child process to stdout : 6458
+Child process to stdout : 6459
+Child process to stdout : 6460
+Child process to stdout : 6461
+Child process to stdout : 6462
+Child process to stdout : 6463
+Child process to stdout : 6464
+Child process to stdout : 6465
+Child process to stdout : 6466
+Child process to stdout : 6467
+Child process to stdout : 6468
+Child process to stdout : 6469
+Child process to stdout : 6470
+Child process to stdout : 6471
+Child process to stdout : 6472
+Child process to stdout : 6473
+Child process to stdout : 6474
+Child process to stdout : 6475
+Child process to stdout : 6476
+Child process to stdout : 6477
+Child process to stdout : 6478
+Child process to stdout : 6479
+Child process to stdout : 6480
+Child process to stdout : 6481
+Child process to stdout : 6482
+Child process to stdout : 6483
+Child process to stdout : 6484
+Child process to stdout : 6485
+Child process to stdout : 6486
+Child process to stdout : 6487
+Child process to stdout : 6488
+Child process to stdout : 6489
+Child process to stdout : 6490
+Child process to stdout : 6491
+Child process to stdout : 6492
+Child process to stdout : 6493
+Child process to stdout : 6494
+Child process to stdout : 6495
+Child process to stdout : 6496
+Child process to stdout : 6497
+Child process to stdout : 6498
+Child process to stdout : 6499
+Child process to stdout : 6500
+Child process to stdout : 6501
+Child process to stdout : 6502
+Child process to stdout : 6503
+Child process to stdout : 6504
+Child process to stdout : 6505
+Child process to stdout : 6506
+Child process to stdout : 6507
+Child process to stdout : 6508
+Child process to stdout : 6509
+Child process to stdout : 6510
+Child process to stdout : 6511
+Child process to stdout : 6512
+Child process to stdout : 6513
+Child process to stdout : 6514
+Child process to stdout : 6515
+Child process to stdout : 6516
+Child process to stdout : 6517
+Child process to stdout : 6518
+Child process to stdout : 6519
+Child process to stdout : 6520
+Child process to stdout : 6521
+Child process to stdout : 6522
+Child process to stdout : 6523
+Child process to stdout : 6524
+Child process to stdout : 6525
+Child process to stdout : 6526
+Child process to stdout : 6527
+Child process to stdout : 6528
+Child process to stdout : 6529
+Child process to stdout : 6530
+Child process to stdout : 6531
+Child process to stdout : 6532
+Child process to stdout : 6533
+Child process to stdout : 6534
+Child process to stdout : 6535
+Child process to stdout : 6536
+Child process to stdout : 6537
+Child process to stdout : 6538
+Child process to stdout : 6539
+Child process to stdout : 6540
+Child process to stdout : 6541
+Child process to stdout : 6542
+Child process to stdout : 6543
+Child process to stdout : 6544
+Child process to stdout : 6545
+Child process to stdout : 6546
+Child process to stdout : 6547
+Child process to stdout : 6548
+Child process to stdout : 6549
+Child process to stdout : 6550
+Child process to stdout : 6551
+Child process to stdout : 6552
+Child process to stdout : 6553
+Child process to stdout : 6554
+Child process to stdout : 6555
+Child process to stdout : 6556
+Child process to stdout : 6557
+Child process to stdout : 6558
+Child process to stdout : 6559
+Child process to stdout : 6560
+Child process to stdout : 6561
+Child process to stdout : 6562
+Child process to stdout : 6563
+Child process to stdout : 6564
+Child process to stdout : 6565
+Child process to stdout : 6566
+Child process to stdout : 6567
+Child process to stdout : 6568
+Child process to stdout : 6569
+Child process to stdout : 6570
+Child process to stdout : 6571
+Child process to stdout : 6572
+Child process to stdout : 6573
+Child process to stdout : 6574
+Child process to stdout : 6575
+Child process to stdout : 6576
+Child process to stdout : 6577
+Child process to stdout : 6578
+Child process to stdout : 6579
+Child process to stdout : 6580
+Child process to stdout : 6581
+Child process to stdout : 6582
+Child process to stdout : 6583
+Child process to stdout : 6584
+Child process to stdout : 6585
+Child process to stdout : 6586
+Child process to stdout : 6587
+Child process to stdout : 6588
+Child process to stdout : 6589
+Child process to stdout : 6590
+Child process to stdout : 6591
+Child process to stdout : 6592
+Child process to stdout : 6593
+Child process to stdout : 6594
+Child process to stdout : 6595
+Child process to stdout : 6596
+Child process to stdout : 6597
+Child process to stdout : 6598
+Child process to stdout : 6599
+Child process to stdout : 6600
+Child process to stdout : 6601
+Child process to stdout : 6602
+Child process to stdout : 6603
+Child process to stdout : 6604
+Child process to stdout : 6605
+Child process to stdout : 6606
+Child process to stdout : 6607
+Child process to stdout : 6608
+Child process to stdout : 6609
+Child process to stdout : 6610
+Child process to stdout : 6611
+Child process to stdout : 6612
+Child process to stdout : 6613
+Child process to stdout : 6614
+Child process to stdout : 6615
+Child process to stdout : 6616
+Child process to stdout : 6617
+Child process to stdout : 6618
+Child process to stdout : 6619
+Child process to stdout : 6620
+Child process to stdout : 6621
+Child process to stdout : 6622
+Child process to stdout : 6623
+Child process to stdout : 6624
+Child process to stdout : 6625
+Child process to stdout : 6626
+Child process to stdout : 6627
+Child process to stdout : 6628
+Child process to stdout : 6629
+Child process to stdout : 6630
+Child process to stdout : 6631
+Child process to stdout : 6632
+Child process to stdout : 6633
+Child process to stdout : 6634
+Child process to stdout : 6635
+Child process to stdout : 6636
+Child process to stdout : 6637
+Child process to stdout : 6638
+Child process to stdout : 6639
+Child process to stdout : 6640
+Child process to stdout : 6641
+Child process to stdout : 6642
+Child process to stdout : 6643
+Child process to stdout : 6644
+Child process to stdout : 6645
+Child process to stdout : 6646
+Child process to stdout : 6647
+Child process to stdout : 6648
+Child process to stdout : 6649
+Child process to stdout : 6650
+Child process to stdout : 6651
+Child process to stdout : 6652
+Child process to stdout : 6653
+Child process to stdout : 6654
+Child process to stdout : 6655
+Child process to stdout : 6656
+Child process to stdout : 6657
+Child process to stdout : 6658
+Child process to stdout : 6659
+Child process to stdout : 6660
+Child process to stdout : 6661
+Child process to stdout : 6662
+Child process to stdout : 6663
+Child process to stdout : 6664
+Child process to stdout : 6665
+Child process to stdout : 6666
+Child process to stdout : 6667
+Child process to stdout : 6668
+Child process to stdout : 6669
+Child process to stdout : 6670
+Child process to stdout : 6671
+Child process to stdout : 6672
+Child process to stdout : 6673
+Child process to stdout : 6674
+Child process to stdout : 6675
+Child process to stdout : 6676
+Child process to stdout : 6677
+Child process to stdout : 6678
+Child process to stdout : 6679
+Child process to stdout : 6680
+Child process to stdout : 6681
+Child process to stdout : 6682
+Child process to stdout : 6683
+Child process to stdout : 6684
+Child process to stdout : 6685
+Child process to stdout : 6686
+Child process to stdout : 6687
+Child process to stdout : 6688
+Child process to stdout : 6689
+Child process to stdout : 6690
+Child process to stdout : 6691
+Child process to stdout : 6692
+Child process to stdout : 6693
+Child process to stdout : 6694
+Child process to stdout : 6695
+Child process to stdout : 6696
+Child process to stdout : 6697
+Child process to stdout : 6698
+Child process to stdout : 6699
+Child process to stdout : 6700
+Child process to stdout : 6701
+Child process to stdout : 6702
+Child process to stdout : 6703
+Child process to stdout : 6704
+Child process to stdout : 6705
+Child process to stdout : 6706
+Child process to stdout : 6707
+Child process to stdout : 6708
+Child process to stdout : 6709
+Child process to stdout : 6710
+Child process to stdout : 6711
+Child process to stdout : 6712
+Child process to stdout : 6713
+Child process to stdout : 6714
+Child process to stdout : 6715
+Child process to stdout : 6716
+Child process to stdout : 6717
+Child process to stdout : 6718
+Child process to stdout : 6719
+Child process to stdout : 6720
+Child process to stdout : 6721
+Child process to stdout : 6722
+Child process to stdout : 6723
+Child process to stdout : 6724
+Child process to stdout : 6725
+Child process to stdout : 6726
+Child process to stdout : 6727
+Child process to stdout : 6728
+Child process to stdout : 6729
+Child process to stdout : 6730
+Child process to stdout : 6731
+Child process to stdout : 6732
+Child process to stdout : 6733
+Child process to stdout : 6734
+Child process to stdout : 6735
+Child process to stdout : 6736
+Child process to stdout : 6737
+Child process to stdout : 6738
+Child process to stdout : 6739
+Child process to stdout : 6740
+Child process to stdout : 6741
+Child process to stdout : 6742
+Child process to stdout : 6743
+Child process to stdout : 6744
+Child process to stdout : 6745
+Child process to stdout : 6746
+Child process to stdout : 6747
+Child process to stdout : 6748
+Child process to stdout : 6749
+Child process to stdout : 6750
+Child process to stdout : 6751
+Child process to stdout : 6752
+Child process to stdout : 6753
+Child process to stdout : 6754
+Child process to stdout : 6755
+Child process to stdout : 6756
+Child process to stdout : 6757
+Child process to stdout : 6758
+Child process to stdout : 6759
+Child process to stdout : 6760
+Child process to stdout : 6761
+Child process to stdout : 6762
+Child process to stdout : 6763
+Child process to stdout : 6764
+Child process to stdout : 6765
+Child process to stdout : 6766
+Child process to stdout : 6767
+Child process to stdout : 6768
+Child process to stdout : 6769
+Child process to stdout : 6770
+Child process to stdout : 6771
+Child process to stdout : 6772
+Child process to stdout : 6773
+Child process to stdout : 6774
+Child process to stdout : 6775
+Child process to stdout : 6776
+Child process to stdout : 6777
+Child process to stdout : 6778
+Child process to stdout : 6779
+Child process to stdout : 6780
+Child process to stdout : 6781
+Child process to stdout : 6782
+Child process to stdout : 6783
+Child process to stdout : 6784
+Child process to stdout : 6785
+Child process to stdout : 6786
+Child process to stdout : 6787
+Child process to stdout : 6788
+Child process to stdout : 6789
+Child process to stdout : 6790
+Child process to stdout : 6791
+Child process to stdout : 6792
+Child process to stdout : 6793
+Child process to stdout : 6794
+Child process to stdout : 6795
+Child process to stdout : 6796
+Child process to stdout : 6797
+Child process to stdout : 6798
+Child process to stdout : 6799
+Child process to stdout : 6800
+Child process to stdout : 6801
+Child process to stdout : 6802
+Child process to stdout : 6803
+Child process to stdout : 6804
+Child process to stdout : 6805
+Child process to stdout : 6806
+Child process to stdout : 6807
+Child process to stdout : 6808
+Child process to stdout : 6809
+Child process to stdout : 6810
+Child process to stdout : 6811
+Child process to stdout : 6812
+Child process to stdout : 6813
+Child process to stdout : 6814
+Child process to stdout : 6815
+Child process to stdout : 6816
+Child process to stdout : 6817
+Child process to stdout : 6818
+Child process to stdout : 6819
+Child process to stdout : 6820
+Child process to stdout : 6821
+Child process to stdout : 6822
+Child process to stdout : 6823
+Child process to stdout : 6824
+Child process to stdout : 6825
+Child process to stdout : 6826
+Child process to stdout : 6827
+Child process to stdout : 6828
+Child process to stdout : 6829
+Child process to stdout : 6830
+Child process to stdout : 6831
+Child process to stdout : 6832
+Child process to stdout : 6833
+Child process to stdout : 6834
+Child process to stdout : 6835
+Child process to stdout : 6836
+Child process to stdout : 6837
+Child process to stdout : 6838
+Child process to stdout : 6839
+Child process to stdout : 6840
+Child process to stdout : 6841
+Child process to stdout : 6842
+Child process to stdout : 6843
+Child process to stdout : 6844
+Child process to stdout : 6845
+Child process to stdout : 6846
+Child process to stdout : 6847
+Child process to stdout : 6848
+Child process to stdout : 6849
+Child process to stdout : 6850
+Child process to stdout : 6851
+Child process to stdout : 6852
+Child process to stdout : 6853
+Child process to stdout : 6854
+Child process to stdout : 6855
+Child process to stdout : 6856
+Child process to stdout : 6857
+Child process to stdout : 6858
+Child process to stdout : 6859
+Child process to stdout : 6860
+Child process to stdout : 6861
+Child process to stdout : 6862
+Child process to stdout : 6863
+Child process to stdout : 6864
+Child process to stdout : 6865
+Child process to stdout : 6866
+Child process to stdout : 6867
+Child process to stdout : 6868
+Child process to stdout : 6869
+Child process to stdout : 6870
+Child process to stdout : 6871
+Child process to stdout : 6872
+Child process to stdout : 6873
+Child process to stdout : 6874
+Child process to stdout : 6875
+Child process to stdout : 6876
+Child process to stdout : 6877
+Child process to stdout : 6878
+Child process to stdout : 6879
+Child process to stdout : 6880
+Child process to stdout : 6881
+Child process to stdout : 6882
+Child process to stdout : 6883
+Child process to stdout : 6884
+Child process to stdout : 6885
+Child process to stdout : 6886
+Child process to stdout : 6887
+Child process to stdout : 6888
+Child process to stdout : 6889
+Child process to stdout : 6890
+Child process to stdout : 6891
+Child process to stdout : 6892
+Child process to stdout : 6893
+Child process to stdout : 6894
+Child process to stdout : 6895
+Child process to stdout : 6896
+Child process to stdout : 6897
+Child process to stdout : 6898
+Child process to stdout : 6899
+Child process to stdout : 6900
+Child process to stdout : 6901
+Child process to stdout : 6902
+Child process to stdout : 6903
+Child process to stdout : 6904
+Child process to stdout : 6905
+Child process to stdout : 6906
+Child process to stdout : 6907
+Child process to stdout : 6908
+Child process to stdout : 6909
+Child process to stdout : 6910
+Child process to stdout : 6911
+Child process to stdout : 6912
+Child process to stdout : 6913
+Child process to stdout : 6914
+Child process to stdout : 6915
+Child process to stdout : 6916
+Child process to stdout : 6917
+Child process to stdout : 6918
+Child process to stdout : 6919
+Child process to stdout : 6920
+Child process to stdout : 6921
+Child process to stdout : 6922
+Child process to stdout : 6923
+Child process to stdout : 6924
+Child process to stdout : 6925
+Child process to stdout : 6926
+Child process to stdout : 6927
+Child process to stdout : 6928
+Child process to stdout : 6929
+Child process to stdout : 6930
+Child process to stdout : 6931
+Child process to stdout : 6932
+Child process to stdout : 6933
+Child process to stdout : 6934
+Child process to stdout : 6935
+Child process to stdout : 6936
+Child process to stdout : 6937
+Child process to stdout : 6938
+Child process to stdout : 6939
+Child process to stdout : 6940
+Child process to stdout : 6941
+Child process to stdout : 6942
+Child process to stdout : 6943
+Child process to stdout : 6944
+Child process to stdout : 6945
+Child process to stdout : 6946
+Child process to stdout : 6947
+Child process to stdout : 6948
+Child process to stdout : 6949
+Child process to stdout : 6950
+Child process to stdout : 6951
+Child process to stdout : 6952
+Child process to stdout : 6953
+Child process to stdout : 6954
+Child process to stdout : 6955
+Child process to stdout : 6956
+Child process to stdout : 6957
+Child process to stdout : 6958
+Child process to stdout : 6959
+Child process to stdout : 6960
+Child process to stdout : 6961
+Child process to stdout : 6962
+Child process to stdout : 6963
+Child process to stdout : 6964
+Child process to stdout : 6965
+Child process to stdout : 6966
+Child process to stdout : 6967
+Child process to stdout : 6968
+Child process to stdout : 6969
+Child process to stdout : 6970
+Child process to stdout : 6971
+Child process to stdout : 6972
+Child process to stdout : 6973
+Child process to stdout : 6974
+Child process to stdout : 6975
+Child process to stdout : 6976
+Child process to stdout : 6977
+Child process to stdout : 6978
+Child process to stdout : 6979
+Child process to stdout : 6980
+Child process to stdout : 6981
+Child process to stdout : 6982
+Child process to stdout : 6983
+Child process to stdout : 6984
+Child process to stdout : 6985
+Child process to stdout : 6986
+Child process to stdout : 6987
+Child process to stdout : 6988
+Child process to stdout : 6989
+Child process to stdout : 6990
+Child process to stdout : 6991
+Child process to stdout : 6992
+Child process to stdout : 6993
+Child process to stdout : 6994
+Child process to stdout : 6995
+Child process to stdout : 6996
+Child process to stdout : 6997
+Child process to stdout : 6998
+Child process to stdout : 6999
+Child process to stdout : 7000
+Child process to stdout : 7001
+Child process to stdout : 7002
+Child process to stdout : 7003
+Child process to stdout : 7004
+Child process to stdout : 7005
+Child process to stdout : 7006
+Child process to stdout : 7007
+Child process to stdout : 7008
+Child process to stdout : 7009
+Child process to stdout : 7010
+Child process to stdout : 7011
+Child process to stdout : 7012
+Child process to stdout : 7013
+Child process to stdout : 7014
+Child process to stdout : 7015
+Child process to stdout : 7016
+Child process to stdout : 7017
+Child process to stdout : 7018
+Child process to stdout : 7019
+Child process to stdout : 7020
+Child process to stdout : 7021
+Child process to stdout : 7022
+Child process to stdout : 7023
+Child process to stdout : 7024
+Child process to stdout : 7025
+Child process to stdout : 7026
+Child process to stdout : 7027
+Child process to stdout : 7028
+Child process to stdout : 7029
+Child process to stdout : 7030
+Child process to stdout : 7031
+Child process to stdout : 7032
+Child process to stdout : 7033
+Child process to stdout : 7034
+Child process to stdout : 7035
+Child process to stdout : 7036
+Child process to stdout : 7037
+Child process to stdout : 7038
+Child process to stdout : 7039
+Child process to stdout : 7040
+Child process to stdout : 7041
+Child process to stdout : 7042
+Child process to stdout : 7043
+Child process to stdout : 7044
+Child process to stdout : 7045
+Child process to stdout : 7046
+Child process to stdout : 7047
+Child process to stdout : 7048
+Child process to stdout : 7049
+Child process to stdout : 7050
+Child process to stdout : 7051
+Child process to stdout : 7052
+Child process to stdout : 7053
+Child process to stdout : 7054
+Child process to stdout : 7055
+Child process to stdout : 7056
+Child process to stdout : 7057
+Child process to stdout : 7058
+Child process to stdout : 7059
+Child process to stdout : 7060
+Child process to stdout : 7061
+Child process to stdout : 7062
+Child process to stdout : 7063
+Child process to stdout : 7064
+Child process to stdout : 7065
+Child process to stdout : 7066
+Child process to stdout : 7067
+Child process to stdout : 7068
+Child process to stdout : 7069
+Child process to stdout : 7070
+Child process to stdout : 7071
+Child process to stdout : 7072
+Child process to stdout : 7073
+Child process to stdout : 7074
+Child process to stdout : 7075
+Child process to stdout : 7076
+Child process to stdout : 7077
+Child process to stdout : 7078
+Child process to stdout : 7079
+Child process to stdout : 7080
+Child process to stdout : 7081
+Child process to stdout : 7082
+Child process to stdout : 7083
+Child process to stdout : 7084
+Child process to stdout : 7085
+Child process to stdout : 7086
+Child process to stdout : 7087
+Child process to stdout : 7088
+Child process to stdout : 7089
+Child process to stdout : 7090
+Child process to stdout : 7091
+Child process to stdout : 7092
+Child process to stdout : 7093
+Child process to stdout : 7094
+Child process to stdout : 7095
+Child process to stdout : 7096
+Child process to stdout : 7097
+Child process to stdout : 7098
+Child process to stdout : 7099
+Child process to stdout : 7100
+Child process to stdout : 7101
+Child process to stdout : 7102
+Child process to stdout : 7103
+Child process to stdout : 7104
+Child process to stdout : 7105
+Child process to stdout : 7106
+Child process to stdout : 7107
+Child process to stdout : 7108
+Child process to stdout : 7109
+Child process to stdout : 7110
+Child process to stdout : 7111
+Child process to stdout : 7112
+Child process to stdout : 7113
+Child process to stdout : 7114
+Child process to stdout : 7115
+Child process to stdout : 7116
+Child process to stdout : 7117
+Child process to stdout : 7118
+Child process to stdout : 7119
+Child process to stdout : 7120
+Child process to stdout : 7121
+Child process to stdout : 7122
+Child process to stdout : 7123
+Child process to stdout : 7124
+Child process to stdout : 7125
+Child process to stdout : 7126
+Child process to stdout : 7127
+Child process to stdout : 7128
+Child process to stdout : 7129
+Child process to stdout : 7130
+Child process to stdout : 7131
+Child process to stdout : 7132
+Child process to stdout : 7133
+Child process to stdout : 7134
+Child process to stdout : 7135
+Child process to stdout : 7136
+Child process to stdout : 7137
+Child process to stdout : 7138
+Child process to stdout : 7139
+Child process to stdout : 7140
+Child process to stdout : 7141
+Child process to stdout : 7142
+Child process to stdout : 7143
+Child process to stdout : 7144
+Child process to stdout : 7145
+Child process to stdout : 7146
+Child process to stdout : 7147
+Child process to stdout : 7148
+Child process to stdout : 7149
+Child process to stdout : 7150
+Child process to stdout : 7151
+Child process to stdout : 7152
+Child process to stdout : 7153
+Child process to stdout : 7154
+Child process to stdout : 7155
+Child process to stdout : 7156
+Child process to stdout : 7157
+Child process to stdout : 7158
+Child process to stdout : 7159
+Child process to stdout : 7160
+Child process to stdout : 7161
+Child process to stdout : 7162
+Child process to stdout : 7163
+Child process to stdout : 7164
+Child process to stdout : 7165
+Child process to stdout : 7166
+Child process to stdout : 7167
+Child process to stdout : 7168
+Child process to stdout : 7169
+Child process to stdout : 7170
+Child process to stdout : 7171
+Child process to stdout : 7172
+Child process to stdout : 7173
+Child process to stdout : 7174
+Child process to stdout : 7175
+Child process to stdout : 7176
+Child process to stdout : 7177
+Child process to stdout : 7178
+Child process to stdout : 7179
+Child process to stdout : 7180
+Child process to stdout : 7181
+Child process to stdout : 7182
+Child process to stdout : 7183
+Child process to stdout : 7184
+Child process to stdout : 7185
+Child process to stdout : 7186
+Child process to stdout : 7187
+Child process to stdout : 7188
+Child process to stdout : 7189
+Child process to stdout : 7190
+Child process to stdout : 7191
+Child process to stdout : 7192
+Child process to stdout : 7193
+Child process to stdout : 7194
+Child process to stdout : 7195
+Child process to stdout : 7196
+Child process to stdout : 7197
+Child process to stdout : 7198
+Child process to stdout : 7199
+Child process to stdout : 7200
+Child process to stdout : 7201
+Child process to stdout : 7202
+Child process to stdout : 7203
+Child process to stdout : 7204
+Child process to stdout : 7205
+Child process to stdout : 7206
+Child process to stdout : 7207
+Child process to stdout : 7208
+Child process to stdout : 7209
+Child process to stdout : 7210
+Child process to stdout : 7211
+Child process to stdout : 7212
+Child process to stdout : 7213
+Child process to stdout : 7214
+Child process to stdout : 7215
+Child process to stdout : 7216
+Child process to stdout : 7217
+Child process to stdout : 7218
+Child process to stdout : 7219
+Child process to stdout : 7220
+Child process to stdout : 7221
+Child process to stdout : 7222
+Child process to stdout : 7223
+Child process to stdout : 7224
+Child process to stdout : 7225
+Child process to stdout : 7226
+Child process to stdout : 7227
+Child process to stdout : 7228
+Child process to stdout : 7229
+Child process to stdout : 7230
+Child process to stdout : 7231
+Child process to stdout : 7232
+Child process to stdout : 7233
+Child process to stdout : 7234
+Child process to stdout : 7235
+Child process to stdout : 7236
+Child process to stdout : 7237
+Child process to stdout : 7238
+Child process to stdout : 7239
+Child process to stdout : 7240
+Child process to stdout : 7241
+Child process to stdout : 7242
+Child process to stdout : 7243
+Child process to stdout : 7244
+Child process to stdout : 7245
+Child process to stdout : 7246
+Child process to stdout : 7247
+Child process to stdout : 7248
+Child process to stdout : 7249
+Child process to stdout : 7250
+Child process to stdout : 7251
+Child process to stdout : 7252
+Child process to stdout : 7253
+Child process to stdout : 7254
+Child process to stdout : 7255
+Child process to stdout : 7256
+Child process to stdout : 7257
+Child process to stdout : 7258
+Child process to stdout : 7259
+Child process to stdout : 7260
+Child process to stdout : 7261
+Child process to stdout : 7262
+Child process to stdout : 7263
+Child process to stdout : 7264
+Child process to stdout : 7265
+Child process to stdout : 7266
+Child process to stdout : 7267
+Child process to stdout : 7268
+Child process to stdout : 7269
+Child process to stdout : 7270
+Child process to stdout : 7271
+Child process to stdout : 7272
+Child process to stdout : 7273
+Child process to stdout : 7274
+Child process to stdout : 7275
+Child process to stdout : 7276
+Child process to stdout : 7277
+Child process to stdout : 7278
+Child process to stdout : 7279
+Child process to stdout : 7280
+Child process to stdout : 7281
+Child process to stdout : 7282
+Child process to stdout : 7283
+Child process to stdout : 7284
+Child process to stdout : 7285
+Child process to stdout : 7286
+Child process to stdout : 7287
+Child process to stdout : 7288
+Child process to stdout : 7289
+Child process to stdout : 7290
+Child process to stdout : 7291
+Child process to stdout : 7292
+Child process to stdout : 7293
+Child process to stdout : 7294
+Child process to stdout : 7295
+Child process to stdout : 7296
+Child process to stdout : 7297
+Child process to stdout : 7298
+Child process to stdout : 7299
+Child process to stdout : 7300
+Child process to stdout : 7301
+Child process to stdout : 7302
+Child process to stdout : 7303
+Child process to stdout : 7304
+Child process to stdout : 7305
+Child process to stdout : 7306
+Child process to stdout : 7307
+Child process to stdout : 7308
+Child process to stdout : 7309
+Child process to stdout : 7310
+Child process to stdout : 7311
+Child process to stdout : 7312
+Child process to stdout : 7313
+Child process to stdout : 7314
+Child process to stdout : 7315
+Child process to stdout : 7316
+Child process to stdout : 7317
+Child process to stdout : 7318
+Child process to stdout : 7319
+Child process to stdout : 7320
+Child process to stdout : 7321
+Child process to stdout : 7322
+Child process to stdout : 7323
+Child process to stdout : 7324
+Child process to stdout : 7325
+Child process to stdout : 7326
+Child process to stdout : 7327
+Child process to stdout : 7328
+Child process to stdout : 7329
+Child process to stdout : 7330
+Child process to stdout : 7331
+Child process to stdout : 7332
+Child process to stdout : 7333
+Child process to stdout : 7334
+Child process to stdout : 7335
+Child process to stdout : 7336
+Child process to stdout : 7337
+Child process to stdout : 7338
+Child process to stdout : 7339
+Child process to stdout : 7340
+Child process to stdout : 7341
+Child process to stdout : 7342
+Child process to stdout : 7343
+Child process to stdout : 7344
+Child process to stdout : 7345
+Child process to stdout : 7346
+Child process to stdout : 7347
+Child process to stdout : 7348
+Child process to stdout : 7349
+Child process to stdout : 7350
+Child process to stdout : 7351
+Child process to stdout : 7352
+Child process to stdout : 7353
+Child process to stdout : 7354
+Child process to stdout : 7355
+Child process to stdout : 7356
+Child process to stdout : 7357
+Child process to stdout : 7358
+Child process to stdout : 7359
+Child process to stdout : 7360
+Child process to stdout : 7361
+Child process to stdout : 7362
+Child process to stdout : 7363
+Child process to stdout : 7364
+Child process to stdout : 7365
+Child process to stdout : 7366
+Child process to stdout : 7367
+Child process to stdout : 7368
+Child process to stdout : 7369
+Child process to stdout : 7370
+Child process to stdout : 7371
+Child process to stdout : 7372
+Child process to stdout : 7373
+Child process to stdout : 7374
+Child process to stdout : 7375
+Child process to stdout : 7376
+Child process to stdout : 7377
+Child process to stdout : 7378
+Child process to stdout : 7379
+Child process to stdout : 7380
+Child process to stdout : 7381
+Child process to stdout : 7382
+Child process to stdout : 7383
+Child process to stdout : 7384
+Child process to stdout : 7385
+Child process to stdout : 7386
+Child process to stdout : 7387
+Child process to stdout : 7388
+Child process to stdout : 7389
+Child process to stdout : 7390
+Child process to stdout : 7391
+Child process to stdout : 7392
+Child process to stdout : 7393
+Child process to stdout : 7394
+Child process to stdout : 7395
+Child process to stdout : 7396
+Child process to stdout : 7397
+Child process to stdout : 7398
+Child process to stdout : 7399
+Child process to stdout : 7400
+Child process to stdout : 7401
+Child process to stdout : 7402
+Child process to stdout : 7403
+Child process to stdout : 7404
+Child process to stdout : 7405
+Child process to stdout : 7406
+Child process to stdout : 7407
+Child process to stdout : 7408
+Child process to stdout : 7409
+Child process to stdout : 7410
+Child process to stdout : 7411
+Child process to stdout : 7412
+Child process to stdout : 7413
+Child process to stdout : 7414
+Child process to stdout : 7415
+Child process to stdout : 7416
+Child process to stdout : 7417
+Child process to stdout : 7418
+Child process to stdout : 7419
+Child process to stdout : 7420
+Child process to stdout : 7421
+Child process to stdout : 7422
+Child process to stdout : 7423
+Child process to stdout : 7424
+Child process to stdout : 7425
+Child process to stdout : 7426
+Child process to stdout : 7427
+Child process to stdout : 7428
+Child process to stdout : 7429
+Child process to stdout : 7430
+Child process to stdout : 7431
+Child process to stdout : 7432
+Child process to stdout : 7433
+Child process to stdout : 7434
+Child process to stdout : 7435
+Child process to stdout : 7436
+Child process to stdout : 7437
+Child process to stdout : 7438
+Child process to stdout : 7439
+Child process to stdout : 7440
+Child process to stdout : 7441
+Child process to stdout : 7442
+Child process to stdout : 7443
+Child process to stdout : 7444
+Child process to stdout : 7445
+Child process to stdout : 7446
+Child process to stdout : 7447
+Child process to stdout : 7448
+Child process to stdout : 7449
+Child process to stdout : 7450
+Child process to stdout : 7451
+Child process to stdout : 7452
+Child process to stdout : 7453
+Child process to stdout : 7454
+Child process to stdout : 7455
+Child process to stdout : 7456
+Child process to stdout : 7457
+Child process to stdout : 7458
+Child process to stdout : 7459
+Child process to stdout : 7460
+Child process to stdout : 7461
+Child process to stdout : 7462
+Child process to stdout : 7463
+Child process to stdout : 7464
+Child process to stdout : 7465
+Child process to stdout : 7466
+Child process to stdout : 7467
+Child process to stdout : 7468
+Child process to stdout : 7469
+Child process to stdout : 7470
+Child process to stdout : 7471
+Child process to stdout : 7472
+Child process to stdout : 7473
+Child process to stdout : 7474
+Child process to stdout : 7475
+Child process to stdout : 7476
+Child process to stdout : 7477
+Child process to stdout : 7478
+Child process to stdout : 7479
+Child process to stdout : 7480
+Child process to stdout : 7481
+Child process to stdout : 7482
+Child process to stdout : 7483
+Child process to stdout : 7484
+Child process to stdout : 7485
+Child process to stdout : 7486
+Child process to stdout : 7487
+Child process to stdout : 7488
+Child process to stdout : 7489
+Child process to stdout : 7490
+Child process to stdout : 7491
+Child process to stdout : 7492
+Child process to stdout : 7493
+Child process to stdout : 7494
+Child process to stdout : 7495
+Child process to stdout : 7496
+Child process to stdout : 7497
+Child process to stdout : 7498
+Child process to stdout : 7499
+Child process to stdout : 7500
+Child process to stdout : 7501
+Child process to stdout : 7502
+Child process to stdout : 7503
+Child process to stdout : 7504
+Child process to stdout : 7505
+Child process to stdout : 7506
+Child process to stdout : 7507
+Child process to stdout : 7508
+Child process to stdout : 7509
+Child process to stdout : 7510
+Child process to stdout : 7511
+Child process to stdout : 7512
+Child process to stdout : 7513
+Child process to stdout : 7514
+Child process to stdout : 7515
+Child process to stdout : 7516
+Child process to stdout : 7517
+Child process to stdout : 7518
+Child process to stdout : 7519
+Child process to stdout : 7520
+Child process to stdout : 7521
+Child process to stdout : 7522
+Child process to stdout : 7523
+Child process to stdout : 7524
+Child process to stdout : 7525
+Child process to stdout : 7526
+Child process to stdout : 7527
+Child process to stdout : 7528
+Child process to stdout : 7529
+Child process to stdout : 7530
+Child process to stdout : 7531
+Child process to stdout : 7532
+Child process to stdout : 7533
+Child process to stdout : 7534
+Child process to stdout : 7535
+Child process to stdout : 7536
+Child process to stdout : 7537
+Child process to stdout : 7538
+Child process to stdout : 7539
+Child process to stdout : 7540
+Child process to stdout : 7541
+Child process to stdout : 7542
+Child process to stdout : 7543
+Child process to stdout : 7544
+Child process to stdout : 7545
+Child process to stdout : 7546
+Child process to stdout : 7547
+Child process to stdout : 7548
+Child process to stdout : 7549
+Child process to stdout : 7550
+Child process to stdout : 7551
+Child process to stdout : 7552
+Child process to stdout : 7553
+Child process to stdout : 7554
+Child process to stdout : 7555
+Child process to stdout : 7556
+Child process to stdout : 7557
+Child process to stdout : 7558
+Child process to stdout : 7559
+Child process to stdout : 7560
+Child process to stdout : 7561
+Child process to stdout : 7562
+Child process to stdout : 7563
+Child process to stdout : 7564
+Child process to stdout : 7565
+Child process to stdout : 7566
+Child process to stdout : 7567
+Child process to stdout : 7568
+Child process to stdout : 7569
+Child process to stdout : 7570
+Child process to stdout : 7571
+Child process to stdout : 7572
+Child process to stdout : 7573
+Child process to stdout : 7574
+Child process to stdout : 7575
+Child process to stdout : 7576
+Child process to stdout : 7577
+Child process to stdout : 7578
+Child process to stdout : 7579
+Child process to stdout : 7580
+Child process to stdout : 7581
+Child process to stdout : 7582
+Child process to stdout : 7583
+Child process to stdout : 7584
+Child process to stdout : 7585
+Child process to stdout : 7586
+Child process to stdout : 7587
+Child process to stdout : 7588
+Child process to stdout : 7589
+Child process to stdout : 7590
+Child process to stdout : 7591
+Child process to stdout : 7592
+Child process to stdout : 7593
+Child process to stdout : 7594
+Child process to stdout : 7595
+Child process to stdout : 7596
+Child process to stdout : 7597
+Child process to stdout : 7598
+Child process to stdout : 7599
+Child process to stdout : 7600
+Child process to stdout : 7601
+Child process to stdout : 7602
+Child process to stdout : 7603
+Child process to stdout : 7604
+Child process to stdout : 7605
+Child process to stdout : 7606
+Child process to stdout : 7607
+Child process to stdout : 7608
+Child process to stdout : 7609
+Child process to stdout : 7610
+Child process to stdout : 7611
+Child process to stdout : 7612
+Child process to stdout : 7613
+Child process to stdout : 7614
+Child process to stdout : 7615
+Child process to stdout : 7616
+Child process to stdout : 7617
+Child process to stdout : 7618
+Child process to stdout : 7619
+Child process to stdout : 7620
+Child process to stdout : 7621
+Child process to stdout : 7622
+Child process to stdout : 7623
+Child process to stdout : 7624
+Child process to stdout : 7625
+Child process to stdout : 7626
+Child process to stdout : 7627
+Child process to stdout : 7628
+Child process to stdout : 7629
+Child process to stdout : 7630
+Child process to stdout : 7631
+Child process to stdout : 7632
+Child process to stdout : 7633
+Child process to stdout : 7634
+Child process to stdout : 7635
+Child process to stdout : 7636
+Child process to stdout : 7637
+Child process to stdout : 7638
+Child process to stdout : 7639
+Child process to stdout : 7640
+Child process to stdout : 7641
+Child process to stdout : 7642
+Child process to stdout : 7643
+Child process to stdout : 7644
+Child process to stdout : 7645
+Child process to stdout : 7646
+Child process to stdout : 7647
+Child process to stdout : 7648
+Child process to stdout : 7649
+Child process to stdout : 7650
+Child process to stdout : 7651
+Child process to stdout : 7652
+Child process to stdout : 7653
+Child process to stdout : 7654
+Child process to stdout : 7655
+Child process to stdout : 7656
+Child process to stdout : 7657
+Child process to stdout : 7658
+Child process to stdout : 7659
+Child process to stdout : 7660
+Child process to stdout : 7661
+Child process to stdout : 7662
+Child process to stdout : 7663
+Child process to stdout : 7664
+Child process to stdout : 7665
+Child process to stdout : 7666
+Child process to stdout : 7667
+Child process to stdout : 7668
+Child process to stdout : 7669
+Child process to stdout : 7670
+Child process to stdout : 7671
+Child process to stdout : 7672
+Child process to stdout : 7673
+Child process to stdout : 7674
+Child process to stdout : 7675
+Child process to stdout : 7676
+Child process to stdout : 7677
+Child process to stdout : 7678
+Child process to stdout : 7679
+Child process to stdout : 7680
+Child process to stdout : 7681
+Child process to stdout : 7682
+Child process to stdout : 7683
+Child process to stdout : 7684
+Child process to stdout : 7685
+Child process to stdout : 7686
+Child process to stdout : 7687
+Child process to stdout : 7688
+Child process to stdout : 7689
+Child process to stdout : 7690
+Child process to stdout : 7691
+Child process to stdout : 7692
+Child process to stdout : 7693
+Child process to stdout : 7694
+Child process to stdout : 7695
+Child process to stdout : 7696
+Child process to stdout : 7697
+Child process to stdout : 7698
+Child process to stdout : 7699
+Child process to stdout : 7700
+Child process to stdout : 7701
+Child process to stdout : 7702
+Child process to stdout : 7703
+Child process to stdout : 7704
+Child process to stdout : 7705
+Child process to stdout : 7706
+Child process to stdout : 7707
+Child process to stdout : 7708
+Child process to stdout : 7709
+Child process to stdout : 7710
+Child process to stdout : 7711
+Child process to stdout : 7712
+Child process to stdout : 7713
+Child process to stdout : 7714
+Child process to stdout : 7715
+Child process to stdout : 7716
+Child process to stdout : 7717
+Child process to stdout : 7718
+Child process to stdout : 7719
+Child process to stdout : 7720
+Child process to stdout : 7721
+Child process to stdout : 7722
+Child process to stdout : 7723
+Child process to stdout : 7724
+Child process to stdout : 7725
+Child process to stdout : 7726
+Child process to stdout : 7727
+Child process to stdout : 7728
+Child process to stdout : 7729
+Child process to stdout : 7730
+Child process to stdout : 7731
+Child process to stdout : 7732
+Child process to stdout : 7733
+Child process to stdout : 7734
+Child process to stdout : 7735
+Child process to stdout : 7736
+Child process to stdout : 7737
+Child process to stdout : 7738
+Child process to stdout : 7739
+Child process to stdout : 7740
+Child process to stdout : 7741
+Child process to stdout : 7742
+Child process to stdout : 7743
+Child process to stdout : 7744
+Child process to stdout : 7745
+Child process to stdout : 7746
+Child process to stdout : 7747
+Child process to stdout : 7748
+Child process to stdout : 7749
+Child process to stdout : 7750
+Child process to stdout : 7751
+Child process to stdout : 7752
+Child process to stdout : 7753
+Child process to stdout : 7754
+Child process to stdout : 7755
+Child process to stdout : 7756
+Child process to stdout : 7757
+Child process to stdout : 7758
+Child process to stdout : 7759
+Child process to stdout : 7760
+Child process to stdout : 7761
+Child process to stdout : 7762
+Child process to stdout : 7763
+Child process to stdout : 7764
+Child process to stdout : 7765
+Child process to stdout : 7766
+Child process to stdout : 7767
+Child process to stdout : 7768
+Child process to stdout : 7769
+Child process to stdout : 7770
+Child process to stdout : 7771
+Child process to stdout : 7772
+Child process to stdout : 7773
+Child process to stdout : 7774
+Child process to stdout : 7775
+Child process to stdout : 7776
+Child process to stdout : 7777
+Child process to stdout : 7778
+Child process to stdout : 7779
+Child process to stdout : 7780
+Child process to stdout : 7781
+Child process to stdout : 7782
+Child process to stdout : 7783
+Child process to stdout : 7784
+Child process to stdout : 7785
+Child process to stdout : 7786
+Child process to stdout : 7787
+Child process to stdout : 7788
+Child process to stdout : 7789
+Child process to stdout : 7790
+Child process to stdout : 7791
+Child process to stdout : 7792
+Child process to stdout : 7793
+Child process to stdout : 7794
+Child process to stdout : 7795
+Child process to stdout : 7796
+Child process to stdout : 7797
+Child process to stdout : 7798
+Child process to stdout : 7799
+Child process to stdout : 7800
+Child process to stdout : 7801
+Child process to stdout : 7802
+Child process to stdout : 7803
+Child process to stdout : 7804
+Child process to stdout : 7805
+Child process to stdout : 7806
+Child process to stdout : 7807
+Child process to stdout : 7808
+Child process to stdout : 7809
+Child process to stdout : 7810
+Child process to stdout : 7811
+Child process to stdout : 7812
+Child process to stdout : 7813
+Child process to stdout : 7814
+Child process to stdout : 7815
+Child process to stdout : 7816
+Child process to stdout : 7817
+Child process to stdout : 7818
+Child process to stdout : 7819
+Child process to stdout : 7820
+Child process to stdout : 7821
+Child process to stdout : 7822
+Child process to stdout : 7823
+Child process to stdout : 7824
+Child process to stdout : 7825
+Child process to stdout : 7826
+Child process to stdout : 7827
+Child process to stdout : 7828
+Child process to stdout : 7829
+Child process to stdout : 7830
+Child process to stdout : 7831
+Child process to stdout : 7832
+Child process to stdout : 7833
+Child process to stdout : 7834
+Child process to stdout : 7835
+Child process to stdout : 7836
+Child process to stdout : 7837
+Child process to stdout : 7838
+Child process to stdout : 7839
+Child process to stdout : 7840
+Child process to stdout : 7841
+Child process to stdout : 7842
+Child process to stdout : 7843
+Child process to stdout : 7844
+Child process to stdout : 7845
+Child process to stdout : 7846
+Child process to stdout : 7847
+Child process to stdout : 7848
+Child process to stdout : 7849
+Child process to stdout : 7850
+Child process to stdout : 7851
+Child process to stdout : 7852
+Child process to stdout : 7853
+Child process to stdout : 7854
+Child process to stdout : 7855
+Child process to stdout : 7856
+Child process to stdout : 7857
+Child process to stdout : 7858
+Child process to stdout : 7859
+Child process to stdout : 7860
+Child process to stdout : 7861
+Child process to stdout : 7862
+Child process to stdout : 7863
+Child process to stdout : 7864
+Child process to stdout : 7865
+Child process to stdout : 7866
+Child process to stdout : 7867
+Child process to stdout : 7868
+Child process to stdout : 7869
+Child process to stdout : 7870
+Child process to stdout : 7871
+Child process to stdout : 7872
+Child process to stdout : 7873
+Child process to stdout : 7874
+Child process to stdout : 7875
+Child process to stdout : 7876
+Child process to stdout : 7877
+Child process to stdout : 7878
+Child process to stdout : 7879
+Child process to stdout : 7880
+Child process to stdout : 7881
+Child process to stdout : 7882
+Child process to stdout : 7883
+Child process to stdout : 7884
+Child process to stdout : 7885
+Child process to stdout : 7886
+Child process to stdout : 7887
+Child process to stdout : 7888
+Child process to stdout : 7889
+Child process to stdout : 7890
+Child process to stdout : 7891
+Child process to stdout : 7892
+Child process to stdout : 7893
+Child process to stdout : 7894
+Child process to stdout : 7895
+Child process to stdout : 7896
+Child process to stdout : 7897
+Child process to stdout : 7898
+Child process to stdout : 7899
+Child process to stdout : 7900
+Child process to stdout : 7901
+Child process to stdout : 7902
+Child process to stdout : 7903
+Child process to stdout : 7904
+Child process to stdout : 7905
+Child process to stdout : 7906
+Child process to stdout : 7907
+Child process to stdout : 7908
+Child process to stdout : 7909
+Child process to stdout : 7910
+Child process to stdout : 7911
+Child process to stdout : 7912
+Child process to stdout : 7913
+Child process to stdout : 7914
+Child process to stdout : 7915
+Child process to stdout : 7916
+Child process to stdout : 7917
+Child process to stdout : 7918
+Child process to stdout : 7919
+Child process to stdout : 7920
+Child process to stdout : 7921
+Child process to stdout : 7922
+Child process to stdout : 7923
+Child process to stdout : 7924
+Child process to stdout : 7925
+Child process to stdout : 7926
+Child process to stdout : 7927
+Child process to stdout : 7928
+Child process to stdout : 7929
+Child process to stdout : 7930
+Child process to stdout : 7931
+Child process to stdout : 7932
+Child process to stdout : 7933
+Child process to stdout : 7934
+Child process to stdout : 7935
+Child process to stdout : 7936
+Child process to stdout : 7937
+Child process to stdout : 7938
+Child process to stdout : 7939
+Child process to stdout : 7940
+Child process to stdout : 7941
+Child process to stdout : 7942
+Child process to stdout : 7943
+Child process to stdout : 7944
+Child process to stdout : 7945
+Child process to stdout : 7946
+Child process to stdout : 7947
+Child process to stdout : 7948
+Child process to stdout : 7949
+Child process to stdout : 7950
+Child process to stdout : 7951
+Child process to stdout : 7952
+Child process to stdout : 7953
+Child process to stdout : 7954
+Child process to stdout : 7955
+Child process to stdout : 7956
+Child process to stdout : 7957
+Child process to stdout : 7958
+Child process to stdout : 7959
+Child process to stdout : 7960
+Child process to stdout : 7961
+Child process to stdout : 7962
+Child process to stdout : 7963
+Child process to stdout : 7964
+Child process to stdout : 7965
+Child process to stdout : 7966
+Child process to stdout : 7967
+Child process to stdout : 7968
+Child process to stdout : 7969
+Child process to stdout : 7970
+Child process to stdout : 7971
+Child process to stdout : 7972
+Child process to stdout : 7973
+Child process to stdout : 7974
+Child process to stdout : 7975
+Child process to stdout : 7976
+Child process to stdout : 7977
+Child process to stdout : 7978
+Child process to stdout : 7979
+Child process to stdout : 7980
+Child process to stdout : 7981
+Child process to stdout : 7982
+Child process to stdout : 7983
+Child process to stdout : 7984
+Child process to stdout : 7985
+Child process to stdout : 7986
+Child process to stdout : 7987
+Child process to stdout : 7988
+Child process to stdout : 7989
+Child process to stdout : 7990
+Child process to stdout : 7991
+Child process to stdout : 7992
+Child process to stdout : 7993
+Child process to stdout : 7994
+Child process to stdout : 7995
+Child process to stdout : 7996
+Child process to stdout : 7997
+Child process to stdout : 7998
+Child process to stdout : 7999
+Child process to stdout : 8000
+Child process to stdout : 8001
+Child process to stdout : 8002
+Child process to stdout : 8003
+Child process to stdout : 8004
+Child process to stdout : 8005
+Child process to stdout : 8006
+Child process to stdout : 8007
+Child process to stdout : 8008
+Child process to stdout : 8009
+Child process to stdout : 8010
+Child process to stdout : 8011
+Child process to stdout : 8012
+Child process to stdout : 8013
+Child process to stdout : 8014
+Child process to stdout : 8015
+Child process to stdout : 8016
+Child process to stdout : 8017
+Child process to stdout : 8018
+Child process to stdout : 8019
+Child process to stdout : 8020
+Child process to stdout : 8021
+Child process to stdout : 8022
+Child process to stdout : 8023
+Child process to stdout : 8024
+Child process to stdout : 8025
+Child process to stdout : 8026
+Child process to stdout : 8027
+Child process to stdout : 8028
+Child process to stdout : 8029
+Child process to stdout : 8030
+Child process to stdout : 8031
+Child process to stdout : 8032
+Child process to stdout : 8033
+Child process to stdout : 8034
+Child process to stdout : 8035
+Child process to stdout : 8036
+Child process to stdout : 8037
+Child process to stdout : 8038
+Child process to stdout : 8039
+Child process to stdout : 8040
+Child process to stdout : 8041
+Child process to stdout : 8042
+Child process to stdout : 8043
+Child process to stdout : 8044
+Child process to stdout : 8045
+Child process to stdout : 8046
+Child process to stdout : 8047
+Child process to stdout : 8048
+Child process to stdout : 8049
+Child process to stdout : 8050
+Child process to stdout : 8051
+Child process to stdout : 8052
+Child process to stdout : 8053
+Child process to stdout : 8054
+Child process to stdout : 8055
+Child process to stdout : 8056
+Child process to stdout : 8057
+Child process to stdout : 8058
+Child process to stdout : 8059
+Child process to stdout : 8060
+Child process to stdout : 8061
+Child process to stdout : 8062
+Child process to stdout : 8063
+Child process to stdout : 8064
+Child process to stdout : 8065
+Child process to stdout : 8066
+Child process to stdout : 8067
+Child process to stdout : 8068
+Child process to stdout : 8069
+Child process to stdout : 8070
+Child process to stdout : 8071
+Child process to stdout : 8072
+Child process to stdout : 8073
+Child process to stdout : 8074
+Child process to stdout : 8075
+Child process to stdout : 8076
+Child process to stdout : 8077
+Child process to stdout : 8078
+Child process to stdout : 8079
+Child process to stdout : 8080
+Child process to stdout : 8081
+Child process to stdout : 8082
+Child process to stdout : 8083
+Child process to stdout : 8084
+Child process to stdout : 8085
+Child process to stdout : 8086
+Child process to stdout : 8087
+Child process to stdout : 8088
+Child process to stdout : 8089
+Child process to stdout : 8090
+Child process to stdout : 8091
+Child process to stdout : 8092
+Child process to stdout : 8093
+Child process to stdout : 8094
+Child process to stdout : 8095
+Child process to stdout : 8096
+Child process to stdout : 8097
+Child process to stdout : 8098
+Child process to stdout : 8099
+Child process to stdout : 8100
+Child process to stdout : 8101
+Child process to stdout : 8102
+Child process to stdout : 8103
+Child process to stdout : 8104
+Child process to stdout : 8105
+Child process to stdout : 8106
+Child process to stdout : 8107
+Child process to stdout : 8108
+Child process to stdout : 8109
+Child process to stdout : 8110
+Child process to stdout : 8111
+Child process to stdout : 8112
+Child process to stdout : 8113
+Child process to stdout : 8114
+Child process to stdout : 8115
+Child process to stdout : 8116
+Child process to stdout : 8117
+Child process to stdout : 8118
+Child process to stdout : 8119
+Child process to stdout : 8120
+Child process to stdout : 8121
+Child process to stdout : 8122
+Child process to stdout : 8123
+Child process to stdout : 8124
+Child process to stdout : 8125
+Child process to stdout : 8126
+Child process to stdout : 8127
+Child process to stdout : 8128
+Child process to stdout : 8129
+Child process to stdout : 8130
+Child process to stdout : 8131
+Child process to stdout : 8132
+Child process to stdout : 8133
+Child process to stdout : 8134
+Child process to stdout : 8135
+Child process to stdout : 8136
+Child process to stdout : 8137
+Child process to stdout : 8138
+Child process to stdout : 8139
+Child process to stdout : 8140
+Child process to stdout : 8141
+Child process to stdout : 8142
+Child process to stdout : 8143
+Child process to stdout : 8144
+Child process to stdout : 8145
+Child process to stdout : 8146
+Child process to stdout : 8147
+Child process to stdout : 8148
+Child process to stdout : 8149
+Child process to stdout : 8150
+Child process to stdout : 8151
+Child process to stdout : 8152
+Child process to stdout : 8153
+Child process to stdout : 8154
+Child process to stdout : 8155
+Child process to stdout : 8156
+Child process to stdout : 8157
+Child process to stdout : 8158
+Child process to stdout : 8159
+Child process to stdout : 8160
+Child process to stdout : 8161
+Child process to stdout : 8162
+Child process to stdout : 8163
+Child process to stdout : 8164
+Child process to stdout : 8165
+Child process to stdout : 8166
+Child process to stdout : 8167
+Child process to stdout : 8168
+Child process to stdout : 8169
+Child process to stdout : 8170
+Child process to stdout : 8171
+Child process to stdout : 8172
+Child process to stdout : 8173
+Child process to stdout : 8174
+Child process to stdout : 8175
+Child process to stdout : 8176
+Child process to stdout : 8177
+Child process to stdout : 8178
+Child process to stdout : 8179
+Child process to stdout : 8180
+Child process to stdout : 8181
+Child process to stdout : 8182
+Child process to stdout : 8183
+Child process to stdout : 8184
+Child process to stdout : 8185
+Child process to stdout : 8186
+Child process to stdout : 8187
+Child process to stdout : 8188
+Child process to stdout : 8189
+Child process to stdout : 8190
+Child process to stdout : 8191
+Child process to stdout : 8192
+Child process to stdout : 8193
+Child process to stdout : 8194
+Child process to stdout : 8195
+Child process to stdout : 8196
+Child process to stdout : 8197
+Child process to stdout : 8198
+Child process to stdout : 8199
+Child process to stdout : 8200
+Child process to stdout : 8201
+Child process to stdout : 8202
+Child process to stdout : 8203
+Child process to stdout : 8204
+Child process to stdout : 8205
+Child process to stdout : 8206
+Child process to stdout : 8207
+Child process to stdout : 8208
+Child process to stdout : 8209
+Child process to stdout : 8210
+Child process to stdout : 8211
+Child process to stdout : 8212
+Child process to stdout : 8213
+Child process to stdout : 8214
+Child process to stdout : 8215
+Child process to stdout : 8216
+Child process to stdout : 8217
+Child process to stdout : 8218
+Child process to stdout : 8219
+Child process to stdout : 8220
+Child process to stdout : 8221
+Child process to stdout : 8222
+Child process to stdout : 8223
+Child process to stdout : 8224
+Child process to stdout : 8225
+Child process to stdout : 8226
+Child process to stdout : 8227
+Child process to stdout : 8228
+Child process to stdout : 8229
+Child process to stdout : 8230
+Child process to stdout : 8231
+Child process to stdout : 8232
+Child process to stdout : 8233
+Child process to stdout : 8234
+Child process to stdout : 8235
+Child process to stdout : 8236
+Child process to stdout : 8237
+Child process to stdout : 8238
+Child process to stdout : 8239
+Child process to stdout : 8240
+Child process to stdout : 8241
+Child process to stdout : 8242
+Child process to stdout : 8243
+Child process to stdout : 8244
+Child process to stdout : 8245
+Child process to stdout : 8246
+Child process to stdout : 8247
+Child process to stdout : 8248
+Child process to stdout : 8249
+Child process to stdout : 8250
+Child process to stdout : 8251
+Child process to stdout : 8252
+Child process to stdout : 8253
+Child process to stdout : 8254
+Child process to stdout : 8255
+Child process to stdout : 8256
+Child process to stdout : 8257
+Child process to stdout : 8258
+Child process to stdout : 8259
+Child process to stdout : 8260
+Child process to stdout : 8261
+Child process to stdout : 8262
+Child process to stdout : 8263
+Child process to stdout : 8264
+Child process to stdout : 8265
+Child process to stdout : 8266
+Child process to stdout : 8267
+Child process to stdout : 8268
+Child process to stdout : 8269
+Child process to stdout : 8270
+Child process to stdout : 8271
+Child process to stdout : 8272
+Child process to stdout : 8273
+Child process to stdout : 8274
+Child process to stdout : 8275
+Child process to stdout : 8276
+Child process to stdout : 8277
+Child process to stdout : 8278
+Child process to stdout : 8279
+Child process to stdout : 8280
+Child process to stdout : 8281
+Child process to stdout : 8282
+Child process to stdout : 8283
+Child process to stdout : 8284
+Child process to stdout : 8285
+Child process to stdout : 8286
+Child process to stdout : 8287
+Child process to stdout : 8288
+Child process to stdout : 8289
+Child process to stdout : 8290
+Child process to stdout : 8291
+Child process to stdout : 8292
+Child process to stdout : 8293
+Child process to stdout : 8294
+Child process to stdout : 8295
+Child process to stdout : 8296
+Child process to stdout : 8297
+Child process to stdout : 8298
+Child process to stdout : 8299
+Child process to stdout : 8300
+Child process to stdout : 8301
+Child process to stdout : 8302
+Child process to stdout : 8303
+Child process to stdout : 8304
+Child process to stdout : 8305
+Child process to stdout : 8306
+Child process to stdout : 8307
+Child process to stdout : 8308
+Child process to stdout : 8309
+Child process to stdout : 8310
+Child process to stdout : 8311
+Child process to stdout : 8312
+Child process to stdout : 8313
+Child process to stdout : 8314
+Child process to stdout : 8315
+Child process to stdout : 8316
+Child process to stdout : 8317
+Child process to stdout : 8318
+Child process to stdout : 8319
+Child process to stdout : 8320
+Child process to stdout : 8321
+Child process to stdout : 8322
+Child process to stdout : 8323
+Child process to stdout : 8324
+Child process to stdout : 8325
+Child process to stdout : 8326
+Child process to stdout : 8327
+Child process to stdout : 8328
+Child process to stdout : 8329
+Child process to stdout : 8330
+Child process to stdout : 8331
+Child process to stdout : 8332
+Child process to stdout : 8333
+Child process to stdout : 8334
+Child process to stdout : 8335
+Child process to stdout : 8336
+Child process to stdout : 8337
+Child process to stdout : 8338
+Child process to stdout : 8339
+Child process to stdout : 8340
+Child process to stdout : 8341
+Child process to stdout : 8342
+Child process to stdout : 8343
+Child process to stdout : 8344
+Child process to stdout : 8345
+Child process to stdout : 8346
+Child process to stdout : 8347
+Child process to stdout : 8348
+Child process to stdout : 8349
+Child process to stdout : 8350
+Child process to stdout : 8351
+Child process to stdout : 8352
+Child process to stdout : 8353
+Child process to stdout : 8354
+Child process to stdout : 8355
+Child process to stdout : 8356
+Child process to stdout : 8357
+Child process to stdout : 8358
+Child process to stdout : 8359
+Child process to stdout : 8360
+Child process to stdout : 8361
+Child process to stdout : 8362
+Child process to stdout : 8363
+Child process to stdout : 8364
+Child process to stdout : 8365
+Child process to stdout : 8366
+Child process to stdout : 8367
+Child process to stdout : 8368
+Child process to stdout : 8369
+Child process to stdout : 8370
+Child process to stdout : 8371
+Child process to stdout : 8372
+Child process to stdout : 8373
+Child process to stdout : 8374
+Child process to stdout : 8375
+Child process to stdout : 8376
+Child process to stdout : 8377
+Child process to stdout : 8378
+Child process to stdout : 8379
+Child process to stdout : 8380
+Child process to stdout : 8381
+Child process to stdout : 8382
+Child process to stdout : 8383
+Child process to stdout : 8384
+Child process to stdout : 8385
+Child process to stdout : 8386
+Child process to stdout : 8387
+Child process to stdout : 8388
+Child process to stdout : 8389
+Child process to stdout : 8390
+Child process to stdout : 8391
+Child process to stdout : 8392
+Child process to stdout : 8393
+Child process to stdout : 8394
+Child process to stdout : 8395
+Child process to stdout : 8396
+Child process to stdout : 8397
+Child process to stdout : 8398
+Child process to stdout : 8399
+Child process to stdout : 8400
+Child process to stdout : 8401
+Child process to stdout : 8402
+Child process to stdout : 8403
+Child process to stdout : 8404
+Child process to stdout : 8405
+Child process to stdout : 8406
+Child process to stdout : 8407
+Child process to stdout : 8408
+Child process to stdout : 8409
+Child process to stdout : 8410
+Child process to stdout : 8411
+Child process to stdout : 8412
+Child process to stdout : 8413
+Child process to stdout : 8414
+Child process to stdout : 8415
+Child process to stdout : 8416
+Child process to stdout : 8417
+Child process to stdout : 8418
+Child process to stdout : 8419
+Child process to stdout : 8420
+Child process to stdout : 8421
+Child process to stdout : 8422
+Child process to stdout : 8423
+Child process to stdout : 8424
+Child process to stdout : 8425
+Child process to stdout : 8426
+Child process to stdout : 8427
+Child process to stdout : 8428
+Child process to stdout : 8429
+Child process to stdout : 8430
+Child process to stdout : 8431
+Child process to stdout : 8432
+Child process to stdout : 8433
+Child process to stdout : 8434
+Child process to stdout : 8435
+Child process to stdout : 8436
+Child process to stdout : 8437
+Child process to stdout : 8438
+Child process to stdout : 8439
+Child process to stdout : 8440
+Child process to stdout : 8441
+Child process to stdout : 8442
+Child process to stdout : 8443
+Child process to stdout : 8444
+Child process to stdout : 8445
+Child process to stdout : 8446
+Child process to stdout : 8447
+Child process to stdout : 8448
+Child process to stdout : 8449
+Child process to stdout : 8450
+Child process to stdout : 8451
+Child process to stdout : 8452
+Child process to stdout : 8453
+Child process to stdout : 8454
+Child process to stdout : 8455
+Child process to stdout : 8456
+Child process to stdout : 8457
+Child process to stdout : 8458
+Child process to stdout : 8459
+Child process to stdout : 8460
+Child process to stdout : 8461
+Child process to stdout : 8462
+Child process to stdout : 8463
+Child process to stdout : 8464
+Child process to stdout : 8465
+Child process to stdout : 8466
+Child process to stdout : 8467
+Child process to stdout : 8468
+Child process to stdout : 8469
+Child process to stdout : 8470
+Child process to stdout : 8471
+Child process to stdout : 8472
+Child process to stdout : 8473
+Child process to stdout : 8474
+Child process to stdout : 8475
+Child process to stdout : 8476
+Child process to stdout : 8477
+Child process to stdout : 8478
+Child process to stdout : 8479
+Child process to stdout : 8480
+Child process to stdout : 8481
+Child process to stdout : 8482
+Child process to stdout : 8483
+Child process to stdout : 8484
+Child process to stdout : 8485
+Child process to stdout : 8486
+Child process to stdout : 8487
+Child process to stdout : 8488
+Child process to stdout : 8489
+Child process to stdout : 8490
+Child process to stdout : 8491
+Child process to stdout : 8492
+Child process to stdout : 8493
+Child process to stdout : 8494
+Child process to stdout : 8495
+Child process to stdout : 8496
+Child process to stdout : 8497
+Child process to stdout : 8498
+Child process to stdout : 8499
+Child process to stdout : 8500
+Child process to stdout : 8501
+Child process to stdout : 8502
+Child process to stdout : 8503
+Child process to stdout : 8504
+Child process to stdout : 8505
+Child process to stdout : 8506
+Child process to stdout : 8507
+Child process to stdout : 8508
+Child process to stdout : 8509
+Child process to stdout : 8510
+Child process to stdout : 8511
+Child process to stdout : 8512
+Child process to stdout : 8513
+Child process to stdout : 8514
+Child process to stdout : 8515
+Child process to stdout : 8516
+Child process to stdout : 8517
+Child process to stdout : 8518
+Child process to stdout : 8519
+Child process to stdout : 8520
+Child process to stdout : 8521
+Child process to stdout : 8522
+Child process to stdout : 8523
+Child process to stdout : 8524
+Child process to stdout : 8525
+Child process to stdout : 8526
+Child process to stdout : 8527
+Child process to stdout : 8528
+Child process to stdout : 8529
+Child process to stdout : 8530
+Child process to stdout : 8531
+Child process to stdout : 8532
+Child process to stdout : 8533
+Child process to stdout : 8534
+Child process to stdout : 8535
+Child process to stdout : 8536
+Child process to stdout : 8537
+Child process to stdout : 8538
+Child process to stdout : 8539
+Child process to stdout : 8540
+Child process to stdout : 8541
+Child process to stdout : 8542
+Child process to stdout : 8543
+Child process to stdout : 8544
+Child process to stdout : 8545
+Child process to stdout : 8546
+Child process to stdout : 8547
+Child process to stdout : 8548
+Child process to stdout : 8549
+Child process to stdout : 8550
+Child process to stdout : 8551
+Child process to stdout : 8552
+Child process to stdout : 8553
+Child process to stdout : 8554
+Child process to stdout : 8555
+Child process to stdout : 8556
+Child process to stdout : 8557
+Child process to stdout : 8558
+Child process to stdout : 8559
+Child process to stdout : 8560
+Child process to stdout : 8561
+Child process to stdout : 8562
+Child process to stdout : 8563
+Child process to stdout : 8564
+Child process to stdout : 8565
+Child process to stdout : 8566
+Child process to stdout : 8567
+Child process to stdout : 8568
+Child process to stdout : 8569
+Child process to stdout : 8570
+Child process to stdout : 8571
+Child process to stdout : 8572
+Child process to stdout : 8573
+Child process to stdout : 8574
+Child process to stdout : 8575
+Child process to stdout : 8576
+Child process to stdout : 8577
+Child process to stdout : 8578
+Child process to stdout : 8579
+Child process to stdout : 8580
+Child process to stdout : 8581
+Child process to stdout : 8582
+Child process to stdout : 8583
+Child process to stdout : 8584
+Child process to stdout : 8585
+Child process to stdout : 8586
+Child process to stdout : 8587
+Child process to stdout : 8588
+Child process to stdout : 8589
+Child process to stdout : 8590
+Child process to stdout : 8591
+Child process to stdout : 8592
+Child process to stdout : 8593
+Child process to stdout : 8594
+Child process to stdout : 8595
+Child process to stdout : 8596
+Child process to stdout : 8597
+Child process to stdout : 8598
+Child process to stdout : 8599
+Child process to stdout : 8600
+Child process to stdout : 8601
+Child process to stdout : 8602
+Child process to stdout : 8603
+Child process to stdout : 8604
+Child process to stdout : 8605
+Child process to stdout : 8606
+Child process to stdout : 8607
+Child process to stdout : 8608
+Child process to stdout : 8609
+Child process to stdout : 8610
+Child process to stdout : 8611
+Child process to stdout : 8612
+Child process to stdout : 8613
+Child process to stdout : 8614
+Child process to stdout : 8615
+Child process to stdout : 8616
+Child process to stdout : 8617
+Child process to stdout : 8618
+Child process to stdout : 8619
+Child process to stdout : 8620
+Child process to stdout : 8621
+Child process to stdout : 8622
+Child process to stdout : 8623
+Child process to stdout : 8624
+Child process to stdout : 8625
+Child process to stdout : 8626
+Child process to stdout : 8627
+Child process to stdout : 8628
+Child process to stdout : 8629
+Child process to stdout : 8630
+Child process to stdout : 8631
+Child process to stdout : 8632
+Child process to stdout : 8633
+Child process to stdout : 8634
+Child process to stdout : 8635
+Child process to stdout : 8636
+Child process to stdout : 8637
+Child process to stdout : 8638
+Child process to stdout : 8639
+Child process to stdout : 8640
+Child process to stdout : 8641
+Child process to stdout : 8642
+Child process to stdout : 8643
+Child process to stdout : 8644
+Child process to stdout : 8645
+Child process to stdout : 8646
+Child process to stdout : 8647
+Child process to stdout : 8648
+Child process to stdout : 8649
+Child process to stdout : 8650
+Child process to stdout : 8651
+Child process to stdout : 8652
+Child process to stdout : 8653
+Child process to stdout : 8654
+Child process to stdout : 8655
+Child process to stdout : 8656
+Child process to stdout : 8657
+Child process to stdout : 8658
+Child process to stdout : 8659
+Child process to stdout : 8660
+Child process to stdout : 8661
+Child process to stdout : 8662
+Child process to stdout : 8663
+Child process to stdout : 8664
+Child process to stdout : 8665
+Child process to stdout : 8666
+Child process to stdout : 8667
+Child process to stdout : 8668
+Child process to stdout : 8669
+Child process to stdout : 8670
+Child process to stdout : 8671
+Child process to stdout : 8672
+Child process to stdout : 8673
+Child process to stdout : 8674
+Child process to stdout : 8675
+Child process to stdout : 8676
+Child process to stdout : 8677
+Child process to stdout : 8678
+Child process to stdout : 8679
+Child process to stdout : 8680
+Child process to stdout : 8681
+Child process to stdout : 8682
+Child process to stdout : 8683
+Child process to stdout : 8684
+Child process to stdout : 8685
+Child process to stdout : 8686
+Child process to stdout : 8687
+Child process to stdout : 8688
+Child process to stdout : 8689
+Child process to stdout : 8690
+Child process to stdout : 8691
+Child process to stdout : 8692
+Child process to stdout : 8693
+Child process to stdout : 8694
+Child process to stdout : 8695
+Child process to stdout : 8696
+Child process to stdout : 8697
+Child process to stdout : 8698
+Child process to stdout : 8699
+Child process to stdout : 8700
+Child process to stdout : 8701
+Child process to stdout : 8702
+Child process to stdout : 8703
+Child process to stdout : 8704
+Child process to stdout : 8705
+Child process to stdout : 8706
+Child process to stdout : 8707
+Child process to stdout : 8708
+Child process to stdout : 8709
+Child process to stdout : 8710
+Child process to stdout : 8711
+Child process to stdout : 8712
+Child process to stdout : 8713
+Child process to stdout : 8714
+Child process to stdout : 8715
+Child process to stdout : 8716
+Child process to stdout : 8717
+Child process to stdout : 8718
+Child process to stdout : 8719
+Child process to stdout : 8720
+Child process to stdout : 8721
+Child process to stdout : 8722
+Child process to stdout : 8723
+Child process to stdout : 8724
+Child process to stdout : 8725
+Child process to stdout : 8726
+Child process to stdout : 8727
+Child process to stdout : 8728
+Child process to stdout : 8729
+Child process to stdout : 8730
+Child process to stdout : 8731
+Child process to stdout : 8732
+Child process to stdout : 8733
+Child process to stdout : 8734
+Child process to stdout : 8735
+Child process to stdout : 8736
+Child process to stdout : 8737
+Child process to stdout : 8738
+Child process to stdout : 8739
+Child process to stdout : 8740
+Child process to stdout : 8741
+Child process to stdout : 8742
+Child process to stdout : 8743
+Child process to stdout : 8744
+Child process to stdout : 8745
+Child process to stdout : 8746
+Child process to stdout : 8747
+Child process to stdout : 8748
+Child process to stdout : 8749
+Child process to stdout : 8750
+Child process to stdout : 8751
+Child process to stdout : 8752
+Child process to stdout : 8753
+Child process to stdout : 8754
+Child process to stdout : 8755
+Child process to stdout : 8756
+Child process to stdout : 8757
+Child process to stdout : 8758
+Child process to stdout : 8759
+Child process to stdout : 8760
+Child process to stdout : 8761
+Child process to stdout : 8762
+Child process to stdout : 8763
+Child process to stdout : 8764
+Child process to stdout : 8765
+Child process to stdout : 8766
+Child process to stdout : 8767
+Child process to stdout : 8768
+Child process to stdout : 8769
+Child process to stdout : 8770
+Child process to stdout : 8771
+Child process to stdout : 8772
+Child process to stdout : 8773
+Child process to stdout : 8774
+Child process to stdout : 8775
+Child process to stdout : 8776
+Child process to stdout : 8777
+Child process to stdout : 8778
+Child process to stdout : 8779
+Child process to stdout : 8780
+Child process to stdout : 8781
+Child process to stdout : 8782
+Child process to stdout : 8783
+Child process to stdout : 8784
+Child process to stdout : 8785
+Child process to stdout : 8786
+Child process to stdout : 8787
+Child process to stdout : 8788
+Child process to stdout : 8789
+Child process to stdout : 8790
+Child process to stdout : 8791
+Child process to stdout : 8792
+Child process to stdout : 8793
+Child process to stdout : 8794
+Child process to stdout : 8795
+Child process to stdout : 8796
+Child process to stdout : 8797
+Child process to stdout : 8798
+Child process to stdout : 8799
+Child process to stdout : 8800
+Child process to stdout : 8801
+Child process to stdout : 8802
+Child process to stdout : 8803
+Child process to stdout : 8804
+Child process to stdout : 8805
+Child process to stdout : 8806
+Child process to stdout : 8807
+Child process to stdout : 8808
+Child process to stdout : 8809
+Child process to stdout : 8810
+Child process to stdout : 8811
+Child process to stdout : 8812
+Child process to stdout : 8813
+Child process to stdout : 8814
+Child process to stdout : 8815
+Child process to stdout : 8816
+Child process to stdout : 8817
+Child process to stdout : 8818
+Child process to stdout : 8819
+Child process to stdout : 8820
+Child process to stdout : 8821
+Child process to stdout : 8822
+Child process to stdout : 8823
+Child process to stdout : 8824
+Child process to stdout : 8825
+Child process to stdout : 8826
+Child process to stdout : 8827
+Child process to stdout : 8828
+Child process to stdout : 8829
+Child process to stdout : 8830
+Child process to stdout : 8831
+Child process to stdout : 8832
+Child process to stdout : 8833
+Child process to stdout : 8834
+Child process to stdout : 8835
+Child process to stdout : 8836
+Child process to stdout : 8837
+Child process to stdout : 8838
+Child process to stdout : 8839
+Child process to stdout : 8840
+Child process to stdout : 8841
+Child process to stdout : 8842
+Child process to stdout : 8843
+Child process to stdout : 8844
+Child process to stdout : 8845
+Child process to stdout : 8846
+Child process to stdout : 8847
+Child process to stdout : 8848
+Child process to stdout : 8849
+Child process to stdout : 8850
+Child process to stdout : 8851
+Child process to stdout : 8852
+Child process to stdout : 8853
+Child process to stdout : 8854
+Child process to stdout : 8855
+Child process to stdout : 8856
+Child process to stdout : 8857
+Child process to stdout : 8858
+Child process to stdout : 8859
+Child process to stdout : 8860
+Child process to stdout : 8861
+Child process to stdout : 8862
+Child process to stdout : 8863
+Child process to stdout : 8864
+Child process to stdout : 8865
+Child process to stdout : 8866
+Child process to stdout : 8867
+Child process to stdout : 8868
+Child process to stdout : 8869
+Child process to stdout : 8870
+Child process to stdout : 8871
+Child process to stdout : 8872
+Child process to stdout : 8873
+Child process to stdout : 8874
+Child process to stdout : 8875
+Child process to stdout : 8876
+Child process to stdout : 8877
+Child process to stdout : 8878
+Child process to stdout : 8879
+Child process to stdout : 8880
+Child process to stdout : 8881
+Child process to stdout : 8882
+Child process to stdout : 8883
+Child process to stdout : 8884
+Child process to stdout : 8885
+Child process to stdout : 8886
+Child process to stdout : 8887
+Child process to stdout : 8888
+Child process to stdout : 8889
+Child process to stdout : 8890
+Child process to stdout : 8891
+Child process to stdout : 8892
+Child process to stdout : 8893
+Child process to stdout : 8894
+Child process to stdout : 8895
+Child process to stdout : 8896
+Child process to stdout : 8897
+Child process to stdout : 8898
+Child process to stdout : 8899
+Child process to stdout : 8900
+Child process to stdout : 8901
+Child process to stdout : 8902
+Child process to stdout : 8903
+Child process to stdout : 8904
+Child process to stdout : 8905
+Child process to stdout : 8906
+Child process to stdout : 8907
+Child process to stdout : 8908
+Child process to stdout : 8909
+Child process to stdout : 8910
+Child process to stdout : 8911
+Child process to stdout : 8912
+Child process to stdout : 8913
+Child process to stdout : 8914
+Child process to stdout : 8915
+Child process to stdout : 8916
+Child process to stdout : 8917
+Child process to stdout : 8918
+Child process to stdout : 8919
+Child process to stdout : 8920
+Child process to stdout : 8921
+Child process to stdout : 8922
+Child process to stdout : 8923
+Child process to stdout : 8924
+Child process to stdout : 8925
+Child process to stdout : 8926
+Child process to stdout : 8927
+Child process to stdout : 8928
+Child process to stdout : 8929
+Child process to stdout : 8930
+Child process to stdout : 8931
+Child process to stdout : 8932
+Child process to stdout : 8933
+Child process to stdout : 8934
+Child process to stdout : 8935
+Child process to stdout : 8936
+Child process to stdout : 8937
+Child process to stdout : 8938
+Child process to stdout : 8939
+Child process to stdout : 8940
+Child process to stdout : 8941
+Child process to stdout : 8942
+Child process to stdout : 8943
+Child process to stdout : 8944
+Child process to stdout : 8945
+Child process to stdout : 8946
+Child process to stdout : 8947
+Child process to stdout : 8948
+Child process to stdout : 8949
+Child process to stdout : 8950
+Child process to stdout : 8951
+Child process to stdout : 8952
+Child process to stdout : 8953
+Child process to stdout : 8954
+Child process to stdout : 8955
+Child process to stdout : 8956
+Child process to stdout : 8957
+Child process to stdout : 8958
+Child process to stdout : 8959
+Child process to stdout : 8960
+Child process to stdout : 8961
+Child process to stdout : 8962
+Child process to stdout : 8963
+Child process to stdout : 8964
+Child process to stdout : 8965
+Child process to stdout : 8966
+Child process to stdout : 8967
+Child process to stdout : 8968
+Child process to stdout : 8969
+Child process to stdout : 8970
+Child process to stdout : 8971
+Child process to stdout : 8972
+Child process to stdout : 8973
+Child process to stdout : 8974
+Child process to stdout : 8975
+Child process to stdout : 8976
+Child process to stdout : 8977
+Child process to stdout : 8978
+Child process to stdout : 8979
+Child process to stdout : 8980
+Child process to stdout : 8981
+Child process to stdout : 8982
+Child process to stdout : 8983
+Child process to stdout : 8984
+Child process to stdout : 8985
+Child process to stdout : 8986
+Child process to stdout : 8987
+Child process to stdout : 8988
+Child process to stdout : 8989
+Child process to stdout : 8990
+Child process to stdout : 8991
+Child process to stdout : 8992
+Child process to stdout : 8993
+Child process to stdout : 8994
+Child process to stdout : 8995
+Child process to stdout : 8996
+Child process to stdout : 8997
+Child process to stdout : 8998
+Child process to stdout : 8999
+Child process to stdout : 9000
+Child process to stdout : 9001
+Child process to stdout : 9002
+Child process to stdout : 9003
+Child process to stdout : 9004
+Child process to stdout : 9005
+Child process to stdout : 9006
+Child process to stdout : 9007
+Child process to stdout : 9008
+Child process to stdout : 9009
+Child process to stdout : 9010
+Child process to stdout : 9011
+Child process to stdout : 9012
+Child process to stdout : 9013
+Child process to stdout : 9014
+Child process to stdout : 9015
+Child process to stdout : 9016
+Child process to stdout : 9017
+Child process to stdout : 9018
+Child process to stdout : 9019
+Child process to stdout : 9020
+Child process to stdout : 9021
+Child process to stdout : 9022
+Child process to stdout : 9023
+Child process to stdout : 9024
+Child process to stdout : 9025
+Child process to stdout : 9026
+Child process to stdout : 9027
+Child process to stdout : 9028
+Child process to stdout : 9029
+Child process to stdout : 9030
+Child process to stdout : 9031
+Child process to stdout : 9032
+Child process to stdout : 9033
+Child process to stdout : 9034
+Child process to stdout : 9035
+Child process to stdout : 9036
+Child process to stdout : 9037
+Child process to stdout : 9038
+Child process to stdout : 9039
+Child process to stdout : 9040
+Child process to stdout : 9041
+Child process to stdout : 9042
+Child process to stdout : 9043
+Child process to stdout : 9044
+Child process to stdout : 9045
+Child process to stdout : 9046
+Child process to stdout : 9047
+Child process to stdout : 9048
+Child process to stdout : 9049
+Child process to stdout : 9050
+Child process to stdout : 9051
+Child process to stdout : 9052
+Child process to stdout : 9053
+Child process to stdout : 9054
+Child process to stdout : 9055
+Child process to stdout : 9056
+Child process to stdout : 9057
+Child process to stdout : 9058
+Child process to stdout : 9059
+Child process to stdout : 9060
+Child process to stdout : 9061
+Child process to stdout : 9062
+Child process to stdout : 9063
+Child process to stdout : 9064
+Child process to stdout : 9065
+Child process to stdout : 9066
+Child process to stdout : 9067
+Child process to stdout : 9068
+Child process to stdout : 9069
+Child process to stdout : 9070
+Child process to stdout : 9071
+Child process to stdout : 9072
+Child process to stdout : 9073
+Child process to stdout : 9074
+Child process to stdout : 9075
+Child process to stdout : 9076
+Child process to stdout : 9077
+Child process to stdout : 9078
+Child process to stdout : 9079
+Child process to stdout : 9080
+Child process to stdout : 9081
+Child process to stdout : 9082
+Child process to stdout : 9083
+Child process to stdout : 9084
+Child process to stdout : 9085
+Child process to stdout : 9086
+Child process to stdout : 9087
+Child process to stdout : 9088
+Child process to stdout : 9089
+Child process to stdout : 9090
+Child process to stdout : 9091
+Child process to stdout : 9092
+Child process to stdout : 9093
+Child process to stdout : 9094
+Child process to stdout : 9095
+Child process to stdout : 9096
+Child process to stdout : 9097
+Child process to stdout : 9098
+Child process to stdout : 9099
+Child process to stdout : 9100
+Child process to stdout : 9101
+Child process to stdout : 9102
+Child process to stdout : 9103
+Child process to stdout : 9104
+Child process to stdout : 9105
+Child process to stdout : 9106
+Child process to stdout : 9107
+Child process to stdout : 9108
+Child process to stdout : 9109
+Child process to stdout : 9110
+Child process to stdout : 9111
+Child process to stdout : 9112
+Child process to stdout : 9113
+Child process to stdout : 9114
+Child process to stdout : 9115
+Child process to stdout : 9116
+Child process to stdout : 9117
+Child process to stdout : 9118
+Child process to stdout : 9119
+Child process to stdout : 9120
+Child process to stdout : 9121
+Child process to stdout : 9122
+Child process to stdout : 9123
+Child process to stdout : 9124
+Child process to stdout : 9125
+Child process to stdout : 9126
+Child process to stdout : 9127
+Child process to stdout : 9128
+Child process to stdout : 9129
+Child process to stdout : 9130
+Child process to stdout : 9131
+Child process to stdout : 9132
+Child process to stdout : 9133
+Child process to stdout : 9134
+Child process to stdout : 9135
+Child process to stdout : 9136
+Child process to stdout : 9137
+Child process to stdout : 9138
+Child process to stdout : 9139
+Child process to stdout : 9140
+Child process to stdout : 9141
+Child process to stdout : 9142
+Child process to stdout : 9143
+Child process to stdout : 9144
+Child process to stdout : 9145
+Child process to stdout : 9146
+Child process to stdout : 9147
+Child process to stdout : 9148
+Child process to stdout : 9149
+Child process to stdout : 9150
+Child process to stdout : 9151
+Child process to stdout : 9152
+Child process to stdout : 9153
+Child process to stdout : 9154
+Child process to stdout : 9155
+Child process to stdout : 9156
+Child process to stdout : 9157
+Child process to stdout : 9158
+Child process to stdout : 9159
+Child process to stdout : 9160
+Child process to stdout : 9161
+Child process to stdout : 9162
+Child process to stdout : 9163
+Child process to stdout : 9164
+Child process to stdout : 9165
+Child process to stdout : 9166
+Child process to stdout : 9167
+Child process to stdout : 9168
+Child process to stdout : 9169
+Child process to stdout : 9170
+Child process to stdout : 9171
+Child process to stdout : 9172
+Child process to stdout : 9173
+Child process to stdout : 9174
+Child process to stdout : 9175
+Child process to stdout : 9176
+Child process to stdout : 9177
+Child process to stdout : 9178
+Child process to stdout : 9179
+Child process to stdout : 9180
+Child process to stdout : 9181
+Child process to stdout : 9182
+Child process to stdout : 9183
+Child process to stdout : 9184
+Child process to stdout : 9185
+Child process to stdout : 9186
+Child process to stdout : 9187
+Child process to stdout : 9188
+Child process to stdout : 9189
+Child process to stdout : 9190
+Child process to stdout : 9191
+Child process to stdout : 9192
+Child process to stdout : 9193
+Child process to stdout : 9194
+Child process to stdout : 9195
+Child process to stdout : 9196
+Child process to stdout : 9197
+Child process to stdout : 9198
+Child process to stdout : 9199
+Child process to stdout : 9200
+Child process to stdout : 9201
+Child process to stdout : 9202
+Child process to stdout : 9203
+Child process to stdout : 9204
+Child process to stdout : 9205
+Child process to stdout : 9206
+Child process to stdout : 9207
+Child process to stdout : 9208
+Child process to stdout : 9209
+Child process to stdout : 9210
+Child process to stdout : 9211
+Child process to stdout : 9212
+Child process to stdout : 9213
+Child process to stdout : 9214
+Child process to stdout : 9215
+Child process to stdout : 9216
+Child process to stdout : 9217
+Child process to stdout : 9218
+Child process to stdout : 9219
+Child process to stdout : 9220
+Child process to stdout : 9221
+Child process to stdout : 9222
+Child process to stdout : 9223
+Child process to stdout : 9224
+Child process to stdout : 9225
+Child process to stdout : 9226
+Child process to stdout : 9227
+Child process to stdout : 9228
+Child process to stdout : 9229
+Child process to stdout : 9230
+Child process to stdout : 9231
+Child process to stdout : 9232
+Child process to stdout : 9233
+Child process to stdout : 9234
+Child process to stdout : 9235
+Child process to stdout : 9236
+Child process to stdout : 9237
+Child process to stdout : 9238
+Child process to stdout : 9239
+Child process to stdout : 9240
+Child process to stdout : 9241
+Child process to stdout : 9242
+Child process to stdout : 9243
+Child process to stdout : 9244
+Child process to stdout : 9245
+Child process to stdout : 9246
+Child process to stdout : 9247
+Child process to stdout : 9248
+Child process to stdout : 9249
+Child process to stdout : 9250
+Child process to stdout : 9251
+Child process to stdout : 9252
+Child process to stdout : 9253
+Child process to stdout : 9254
+Child process to stdout : 9255
+Child process to stdout : 9256
+Child process to stdout : 9257
+Child process to stdout : 9258
+Child process to stdout : 9259
+Child process to stdout : 9260
+Child process to stdout : 9261
+Child process to stdout : 9262
+Child process to stdout : 9263
+Child process to stdout : 9264
+Child process to stdout : 9265
+Child process to stdout : 9266
+Child process to stdout : 9267
+Child process to stdout : 9268
+Child process to stdout : 9269
+Child process to stdout : 9270
+Child process to stdout : 9271
+Child process to stdout : 9272
+Child process to stdout : 9273
+Child process to stdout : 9274
+Child process to stdout : 9275
+Child process to stdout : 9276
+Child process to stdout : 9277
+Child process to stdout : 9278
+Child process to stdout : 9279
+Child process to stdout : 9280
+Child process to stdout : 9281
+Child process to stdout : 9282
+Child process to stdout : 9283
+Child process to stdout : 9284
+Child process to stdout : 9285
+Child process to stdout : 9286
+Child process to stdout : 9287
+Child process to stdout : 9288
+Child process to stdout : 9289
+Child process to stdout : 9290
+Child process to stdout : 9291
+Child process to stdout : 9292
+Child process to stdout : 9293
+Child process to stdout : 9294
+Child process to stdout : 9295
+Child process to stdout : 9296
+Child process to stdout : 9297
+Child process to stdout : 9298
+Child process to stdout : 9299
+Child process to stdout : 9300
+Child process to stdout : 9301
+Child process to stdout : 9302
+Child process to stdout : 9303
+Child process to stdout : 9304
+Child process to stdout : 9305
+Child process to stdout : 9306
+Child process to stdout : 9307
+Child process to stdout : 9308
+Child process to stdout : 9309
+Child process to stdout : 9310
+Child process to stdout : 9311
+Child process to stdout : 9312
+Child process to stdout : 9313
+Child process to stdout : 9314
+Child process to stdout : 9315
+Child process to stdout : 9316
+Child process to stdout : 9317
+Child process to stdout : 9318
+Child process to stdout : 9319
+Child process to stdout : 9320
+Child process to stdout : 9321
+Child process to stdout : 9322
+Child process to stdout : 9323
+Child process to stdout : 9324
+Child process to stdout : 9325
+Child process to stdout : 9326
+Child process to stdout : 9327
+Child process to stdout : 9328
+Child process to stdout : 9329
+Child process to stdout : 9330
+Child process to stdout : 9331
+Child process to stdout : 9332
+Child process to stdout : 9333
+Child process to stdout : 9334
+Child process to stdout : 9335
+Child process to stdout : 9336
+Child process to stdout : 9337
+Child process to stdout : 9338
+Child process to stdout : 9339
+Child process to stdout : 9340
+Child process to stdout : 9341
+Child process to stdout : 9342
+Child process to stdout : 9343
+Child process to stdout : 9344
+Child process to stdout : 9345
+Child process to stdout : 9346
+Child process to stdout : 9347
+Child process to stdout : 9348
+Child process to stdout : 9349
+Child process to stdout : 9350
+Child process to stdout : 9351
+Child process to stdout : 9352
+Child process to stdout : 9353
+Child process to stdout : 9354
+Child process to stdout : 9355
+Child process to stdout : 9356
+Child process to stdout : 9357
+Child process to stdout : 9358
+Child process to stdout : 9359
+Child process to stdout : 9360
+Child process to stdout : 9361
+Child process to stdout : 9362
+Child process to stdout : 9363
+Child process to stdout : 9364
+Child process to stdout : 9365
+Child process to stdout : 9366
+Child process to stdout : 9367
+Child process to stdout : 9368
+Child process to stdout : 9369
+Child process to stdout : 9370
+Child process to stdout : 9371
+Child process to stdout : 9372
+Child process to stdout : 9373
+Child process to stdout : 9374
+Child process to stdout : 9375
+Child process to stdout : 9376
+Child process to stdout : 9377
+Child process to stdout : 9378
+Child process to stdout : 9379
+Child process to stdout : 9380
+Child process to stdout : 9381
+Child process to stdout : 9382
+Child process to stdout : 9383
+Child process to stdout : 9384
+Child process to stdout : 9385
+Child process to stdout : 9386
+Child process to stdout : 9387
+Child process to stdout : 9388
+Child process to stdout : 9389
+Child process to stdout : 9390
+Child process to stdout : 9391
+Child process to stdout : 9392
+Child process to stdout : 9393
+Child process to stdout : 9394
+Child process to stdout : 9395
+Child process to stdout : 9396
+Child process to stdout : 9397
+Child process to stdout : 9398
+Child process to stdout : 9399
+Child process to stdout : 9400
+Child process to stdout : 9401
+Child process to stdout : 9402
+Child process to stdout : 9403
+Child process to stdout : 9404
+Child process to stdout : 9405
+Child process to stdout : 9406
+Child process to stdout : 9407
+Child process to stdout : 9408
+Child process to stdout : 9409
+Child process to stdout : 9410
+Child process to stdout : 9411
+Child process to stdout : 9412
+Child process to stdout : 9413
+Child process to stdout : 9414
+Child process to stdout : 9415
+Child process to stdout : 9416
+Child process to stdout : 9417
+Child process to stdout : 9418
+Child process to stdout : 9419
+Child process to stdout : 9420
+Child process to stdout : 9421
+Child process to stdout : 9422
+Child process to stdout : 9423
+Child process to stdout : 9424
+Child process to stdout : 9425
+Child process to stdout : 9426
+Child process to stdout : 9427
+Child process to stdout : 9428
+Child process to stdout : 9429
+Child process to stdout : 9430
+Child process to stdout : 9431
+Child process to stdout : 9432
+Child process to stdout : 9433
+Child process to stdout : 9434
+Child process to stdout : 9435
+Child process to stdout : 9436
+Child process to stdout : 9437
+Child process to stdout : 9438
+Child process to stdout : 9439
+Child process to stdout : 9440
+Child process to stdout : 9441
+Child process to stdout : 9442
+Child process to stdout : 9443
+Child process to stdout : 9444
+Child process to stdout : 9445
+Child process to stdout : 9446
+Child process to stdout : 9447
+Child process to stdout : 9448
+Child process to stdout : 9449
+Child process to stdout : 9450
+Child process to stdout : 9451
+Child process to stdout : 9452
+Child process to stdout : 9453
+Child process to stdout : 9454
+Child process to stdout : 9455
+Child process to stdout : 9456
+Child process to stdout : 9457
+Child process to stdout : 9458
+Child process to stdout : 9459
+Child process to stdout : 9460
+Child process to stdout : 9461
+Child process to stdout : 9462
+Child process to stdout : 9463
+Child process to stdout : 9464
+Child process to stdout : 9465
+Child process to stdout : 9466
+Child process to stdout : 9467
+Child process to stdout : 9468
+Child process to stdout : 9469
+Child process to stdout : 9470
+Child process to stdout : 9471
+Child process to stdout : 9472
+Child process to stdout : 9473
+Child process to stdout : 9474
+Child process to stdout : 9475
+Child process to stdout : 9476
+Child process to stdout : 9477
+Child process to stdout : 9478
+Child process to stdout : 9479
+Child process to stdout : 9480
+Child process to stdout : 9481
+Child process to stdout : 9482
+Child process to stdout : 9483
+Child process to stdout : 9484
+Child process to stdout : 9485
+Child process to stdout : 9486
+Child process to stdout : 9487
+Child process to stdout : 9488
+Child process to stdout : 9489
+Child process to stdout : 9490
+Child process to stdout : 9491
+Child process to stdout : 9492
+Child process to stdout : 9493
+Child process to stdout : 9494
+Child process to stdout : 9495
+Child process to stdout : 9496
+Child process to stdout : 9497
+Child process to stdout : 9498
+Child process to stdout : 9499
+Child process to stdout : 9500
+Child process to stdout : 9501
+Child process to stdout : 9502
+Child process to stdout : 9503
+Child process to stdout : 9504
+Child process to stdout : 9505
+Child process to stdout : 9506
+Child process to stdout : 9507
+Child process to stdout : 9508
+Child process to stdout : 9509
+Child process to stdout : 9510
+Child process to stdout : 9511
+Child process to stdout : 9512
+Child process to stdout : 9513
+Child process to stdout : 9514
+Child process to stdout : 9515
+Child process to stdout : 9516
+Child process to stdout : 9517
+Child process to stdout : 9518
+Child process to stdout : 9519
+Child process to stdout : 9520
+Child process to stdout : 9521
+Child process to stdout : 9522
+Child process to stdout : 9523
+Child process to stdout : 9524
+Child process to stdout : 9525
+Child process to stdout : 9526
+Child process to stdout : 9527
+Child process to stdout : 9528
+Child process to stdout : 9529
+Child process to stdout : 9530
+Child process to stdout : 9531
+Child process to stdout : 9532
+Child process to stdout : 9533
+Child process to stdout : 9534
+Child process to stdout : 9535
+Child process to stdout : 9536
+Child process to stdout : 9537
+Child process to stdout : 9538
+Child process to stdout : 9539
+Child process to stdout : 9540
+Child process to stdout : 9541
+Child process to stdout : 9542
+Child process to stdout : 9543
+Child process to stdout : 9544
+Child process to stdout : 9545
+Child process to stdout : 9546
+Child process to stdout : 9547
+Child process to stdout : 9548
+Child process to stdout : 9549
+Child process to stdout : 9550
+Child process to stdout : 9551
+Child process to stdout : 9552
+Child process to stdout : 9553
+Child process to stdout : 9554
+Child process to stdout : 9555
+Child process to stdout : 9556
+Child process to stdout : 9557
+Child process to stdout : 9558
+Child process to stdout : 9559
+Child process to stdout : 9560
+Child process to stdout : 9561
+Child process to stdout : 9562
+Child process to stdout : 9563
+Child process to stdout : 9564
+Child process to stdout : 9565
+Child process to stdout : 9566
+Child process to stdout : 9567
+Child process to stdout : 9568
+Child process to stdout : 9569
+Child process to stdout : 9570
+Child process to stdout : 9571
+Child process to stdout : 9572
+Child process to stdout : 9573
+Child process to stdout : 9574
+Child process to stdout : 9575
+Child process to stdout : 9576
+Child process to stdout : 9577
+Child process to stdout : 9578
+Child process to stdout : 9579
+Child process to stdout : 9580
+Child process to stdout : 9581
+Child process to stdout : 9582
+Child process to stdout : 9583
+Child process to stdout : 9584
+Child process to stdout : 9585
+Child process to stdout : 9586
+Child process to stdout : 9587
+Child process to stdout : 9588
+Child process to stdout : 9589
+Child process to stdout : 9590
+Child process to stdout : 9591
+Child process to stdout : 9592
+Child process to stdout : 9593
+Child process to stdout : 9594
+Child process to stdout : 9595
+Child process to stdout : 9596
+Child process to stdout : 9597
+Child process to stdout : 9598
+Child process to stdout : 9599
+Child process to stdout : 9600
+Child process to stdout : 9601
+Child process to stdout : 9602
+Child process to stdout : 9603
+Child process to stdout : 9604
+Child process to stdout : 9605
+Child process to stdout : 9606
+Child process to stdout : 9607
+Child process to stdout : 9608
+Child process to stdout : 9609
+Child process to stdout : 9610
+Child process to stdout : 9611
+Child process to stdout : 9612
+Child process to stdout : 9613
+Child process to stdout : 9614
+Child process to stdout : 9615
+Child process to stdout : 9616
+Child process to stdout : 9617
+Child process to stdout : 9618
+Child process to stdout : 9619
+Child process to stdout : 9620
+Child process to stdout : 9621
+Child process to stdout : 9622
+Child process to stdout : 9623
+Child process to stdout : 9624
+Child process to stdout : 9625
+Child process to stdout : 9626
+Child process to stdout : 9627
+Child process to stdout : 9628
+Child process to stdout : 9629
+Child process to stdout : 9630
+Child process to stdout : 9631
+Child process to stdout : 9632
+Child process to stdout : 9633
+Child process to stdout : 9634
+Child process to stdout : 9635
+Child process to stdout : 9636
+Child process to stdout : 9637
+Child process to stdout : 9638
+Child process to stdout : 9639
+Child process to stdout : 9640
+Child process to stdout : 9641
+Child process to stdout : 9642
+Child process to stdout : 9643
+Child process to stdout : 9644
+Child process to stdout : 9645
+Child process to stdout : 9646
+Child process to stdout : 9647
+Child process to stdout : 9648
+Child process to stdout : 9649
+Child process to stdout : 9650
+Child process to stdout : 9651
+Child process to stdout : 9652
+Child process to stdout : 9653
+Child process to stdout : 9654
+Child process to stdout : 9655
+Child process to stdout : 9656
+Child process to stdout : 9657
+Child process to stdout : 9658
+Child process to stdout : 9659
+Child process to stdout : 9660
+Child process to stdout : 9661
+Child process to stdout : 9662
+Child process to stdout : 9663
+Child process to stdout : 9664
+Child process to stdout : 9665
+Child process to stdout : 9666
+Child process to stdout : 9667
+Child process to stdout : 9668
+Child process to stdout : 9669
+Child process to stdout : 9670
+Child process to stdout : 9671
+Child process to stdout : 9672
+Child process to stdout : 9673
+Child process to stdout : 9674
+Child process to stdout : 9675
+Child process to stdout : 9676
+Child process to stdout : 9677
+Child process to stdout : 9678
+Child process to stdout : 9679
+Child process to stdout : 9680
+Child process to stdout : 9681
+Child process to stdout : 9682
+Child process to stdout : 9683
+Child process to stdout : 9684
+Child process to stdout : 9685
+Child process to stdout : 9686
+Child process to stdout : 9687
+Child process to stdout : 9688
+Child process to stdout : 9689
+Child process to stdout : 9690
+Child process to stdout : 9691
+Child process to stdout : 9692
+Child process to stdout : 9693
+Child process to stdout : 9694
+Child process to stdout : 9695
+Child process to stdout : 9696
+Child process to stdout : 9697
+Child process to stdout : 9698
+Child process to stdout : 9699
+Child process to stdout : 9700
+Child process to stdout : 9701
+Child process to stdout : 9702
+Child process to stdout : 9703
+Child process to stdout : 9704
+Child process to stdout : 9705
+Child process to stdout : 9706
+Child process to stdout : 9707
+Child process to stdout : 9708
+Child process to stdout : 9709
+Child process to stdout : 9710
+Child process to stdout : 9711
+Child process to stdout : 9712
+Child process to stdout : 9713
+Child process to stdout : 9714
+Child process to stdout : 9715
+Child process to stdout : 9716
+Child process to stdout : 9717
+Child process to stdout : 9718
+Child process to stdout : 9719
+Child process to stdout : 9720
+Child process to stdout : 9721
+Child process to stdout : 9722
+Child process to stdout : 9723
+Child process to stdout : 9724
+Child process to stdout : 9725
+Child process to stdout : 9726
+Child process to stdout : 9727
+Child process to stdout : 9728
+Child process to stdout : 9729
+Child process to stdout : 9730
+Child process to stdout : 9731
+Child process to stdout : 9732
+Child process to stdout : 9733
+Child process to stdout : 9734
+Child process to stdout : 9735
+Child process to stdout : 9736
+Child process to stdout : 9737
+Child process to stdout : 9738
+Child process to stdout : 9739
+Child process to stdout : 9740
+Child process to stdout : 9741
+Child process to stdout : 9742
+Child process to stdout : 9743
+Child process to stdout : 9744
+Child process to stdout : 9745
+Child process to stdout : 9746
+Child process to stdout : 9747
+Child process to stdout : 9748
+Child process to stdout : 9749
+Child process to stdout : 9750
+Child process to stdout : 9751
+Child process to stdout : 9752
+Child process to stdout : 9753
+Child process to stdout : 9754
+Child process to stdout : 9755
+Child process to stdout : 9756
+Child process to stdout : 9757
+Child process to stdout : 9758
+Child process to stdout : 9759
+Child process to stdout : 9760
+Child process to stdout : 9761
+Child process to stdout : 9762
+Child process to stdout : 9763
+Child process to stdout : 9764
+Child process to stdout : 9765
+Child process to stdout : 9766
+Child process to stdout : 9767
+Child process to stdout : 9768
+Child process to stdout : 9769
+Child process to stdout : 9770
+Child process to stdout : 9771
+Child process to stdout : 9772
+Child process to stdout : 9773
+Child process to stdout : 9774
+Child process to stdout : 9775
+Child process to stdout : 9776
+Child process to stdout : 9777
+Child process to stdout : 9778
+Child process to stdout : 9779
+Child process to stdout : 9780
+Child process to stdout : 9781
+Child process to stdout : 9782
+Child process to stdout : 9783
+Child process to stdout : 9784
+Child process to stdout : 9785
+Child process to stdout : 9786
+Child process to stdout : 9787
+Child process to stdout : 9788
+Child process to stdout : 9789
+Child process to stdout : 9790
+Child process to stdout : 9791
+Child process to stdout : 9792
+Child process to stdout : 9793
+Child process to stdout : 9794
+Child process to stdout : 9795
+Child process to stdout : 9796
+Child process to stdout : 9797
+Child process to stdout : 9798
+Child process to stdout : 9799
+Child process to stdout : 9800
+Child process to stdout : 9801
+Child process to stdout : 9802
+Child process to stdout : 9803
+Child process to stdout : 9804
+Child process to stdout : 9805
+Child process to stdout : 9806
+Child process to stdout : 9807
+Child process to stdout : 9808
+Child process to stdout : 9809
+Child process to stdout : 9810
+Child process to stdout : 9811
+Child process to stdout : 9812
+Child process to stdout : 9813
+Child process to stdout : 9814
+Child process to stdout : 9815
+Child process to stdout : 9816
+Child process to stdout : 9817
+Child process to stdout : 9818
+Child process to stdout : 9819
+Child process to stdout : 9820
+Child process to stdout : 9821
+Child process to stdout : 9822
+Child process to stdout : 9823
+Child process to stdout : 9824
+Child process to stdout : 9825
+Child process to stdout : 9826
+Child process to stdout : 9827
+Child process to stdout : 9828
+Child process to stdout : 9829
+Child process to stdout : 9830
+Child process to stdout : 9831
+Child process to stdout : 9832
+Child process to stdout : 9833
+Child process to stdout : 9834
+Child process to stdout : 9835
+Child process to stdout : 9836
+Child process to stdout : 9837
+Child process to stdout : 9838
+Child process to stdout : 9839
+Child process to stdout : 9840
+Child process to stdout : 9841
+Child process to stdout : 9842
+Child process to stdout : 9843
+Child process to stdout : 9844
+Child process to stdout : 9845
+Child process to stdout : 9846
+Child process to stdout : 9847
+Child process to stdout : 9848
+Child process to stdout : 9849
+Child process to stdout : 9850
+Child process to stdout : 9851
+Child process to stdout : 9852
+Child process to stdout : 9853
+Child process to stdout : 9854
+Child process to stdout : 9855
+Child process to stdout : 9856
+Child process to stdout : 9857
+Child process to stdout : 9858
+Child process to stdout : 9859
+Child process to stdout : 9860
+Child process to stdout : 9861
+Child process to stdout : 9862
+Child process to stdout : 9863
+Child process to stdout : 9864
+Child process to stdout : 9865
+Child process to stdout : 9866
+Child process to stdout : 9867
+Child process to stdout : 9868
+Child process to stdout : 9869
+Child process to stdout : 9870
+Child process to stdout : 9871
+Child process to stdout : 9872
+Child process to stdout : 9873
+Child process to stdout : 9874
+Child process to stdout : 9875
+Child process to stdout : 9876
+Child process to stdout : 9877
+Child process to stdout : 9878
+Child process to stdout : 9879
+Child process to stdout : 9880
+Child process to stdout : 9881
+Child process to stdout : 9882
+Child process to stdout : 9883
+Child process to stdout : 9884
+Child process to stdout : 9885
+Child process to stdout : 9886
+Child process to stdout : 9887
+Child process to stdout : 9888
+Child process to stdout : 9889
+Child process to stdout : 9890
+Child process to stdout : 9891
+Child process to stdout : 9892
+Child process to stdout : 9893
+Child process to stdout : 9894
+Child process to stdout : 9895
+Child process to stdout : 9896
+Child process to stdout : 9897
+Child process to stdout : 9898
+Child process to stdout : 9899
+Child process to stdout : 9900
+Child process to stdout : 9901
+Child process to stdout : 9902
+Child process to stdout : 9903
+Child process to stdout : 9904
+Child process to stdout : 9905
+Child process to stdout : 9906
+Child process to stdout : 9907
+Child process to stdout : 9908
+Child process to stdout : 9909
+Child process to stdout : 9910
+Child process to stdout : 9911
+Child process to stdout : 9912
+Child process to stdout : 9913
+Child process to stdout : 9914
+Child process to stdout : 9915
+Child process to stdout : 9916
+Child process to stdout : 9917
+Child process to stdout : 9918
+Child process to stdout : 9919
+Child process to stdout : 9920
+Child process to stdout : 9921
+Child process to stdout : 9922
+Child process to stdout : 9923
+Child process to stdout : 9924
+Child process to stdout : 9925
+Child process to stdout : 9926
+Child process to stdout : 9927
+Child process to stdout : 9928
+Child process to stdout : 9929
+Child process to stdout : 9930
+Child process to stdout : 9931
+Child process to stdout : 9932
+Child process to stdout : 9933
+Child process to stdout : 9934
+Child process to stdout : 9935
+Child process to stdout : 9936
+Child process to stdout : 9937
+Child process to stdout : 9938
+Child process to stdout : 9939
+Child process to stdout : 9940
+Child process to stdout : 9941
+Child process to stdout : 9942
+Child process to stdout : 9943
+Child process to stdout : 9944
+Child process to stdout : 9945
+Child process to stdout : 9946
+Child process to stdout : 9947
+Child process to stdout : 9948
+Child process to stdout : 9949
+Child process to stdout : 9950
+Child process to stdout : 9951
+Child process to stdout : 9952
+Child process to stdout : 9953
+Child process to stdout : 9954
+Child process to stdout : 9955
+Child process to stdout : 9956
+Child process to stdout : 9957
+Child process to stdout : 9958
+Child process to stdout : 9959
+Child process to stdout : 9960
+Child process to stdout : 9961
+Child process to stdout : 9962
+Child process to stdout : 9963
+Child process to stdout : 9964
+Child process to stdout : 9965
+Child process to stdout : 9966
+Child process to stdout : 9967
+Child process to stdout : 9968
+Child process to stdout : 9969
+Child process to stdout : 9970
+Child process to stdout : 9971
+Child process to stdout : 9972
+Child process to stdout : 9973
+Child process to stdout : 9974
+Child process to stdout : 9975
+Child process to stdout : 9976
+Child process to stdout : 9977
+Child process to stdout : 9978
+Child process to stdout : 9979
+Child process to stdout : 9980
+Child process to stdout : 9981
+Child process to stdout : 9982
+Child process to stdout : 9983
+Child process to stdout : 9984
+Child process to stdout : 9985
+Child process to stdout : 9986
+Child process to stdout : 9987
+Child process to stdout : 9988
+Child process to stdout : 9989
+Child process to stdout : 9990
+Child process to stdout : 9991
+Child process to stdout : 9992
+Child process to stdout : 9993
+Child process to stdout : 9994
+Child process to stdout : 9995
+Child process to stdout : 9996
+Child process to stdout : 9997
+Child process to stdout : 9998
+Child process to stdout : 9999
diff --git a/third_party/rules_rust/test/proto/BUILD.bazel b/third_party/rules_rust/test/proto/BUILD.bazel
new file mode 100644
index 0000000..0e8189e
--- /dev/null
+++ b/third_party/rules_rust/test/proto/BUILD.bazel
@@ -0,0 +1,20 @@
+load("@rules_proto//proto:defs.bzl", "proto_library")
+load("@rules_rust//proto:proto.bzl", "rust_proto_library")
+
+proto_library(
+    name = "a_proto",
+    srcs = ["a.proto"],
+    strip_import_prefix = "",
+)
+
+proto_library(
+    name = "b_proto",
+    srcs = ["b.proto"],
+    strip_import_prefix = "",
+    deps = [":a_proto"],
+)
+
+rust_proto_library(
+    name = "b_rust",
+    deps = [":b_proto"],
+)
diff --git a/third_party/rules_rust/test/proto/a.proto b/third_party/rules_rust/test/proto/a.proto
new file mode 100644
index 0000000..056f5bf
--- /dev/null
+++ b/third_party/rules_rust/test/proto/a.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+message A {
+    string a = 1;
+}
\ No newline at end of file
diff --git a/third_party/rules_rust/test/proto/b.proto b/third_party/rules_rust/test/proto/b.proto
new file mode 100644
index 0000000..e69503a
--- /dev/null
+++ b/third_party/rules_rust/test/proto/b.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+import "a.proto";
+
+message B {
+    A a = 1;
+}
\ No newline at end of file
diff --git a/third_party/rules_rust/test/renamed_deps/BUILD.bazel b/third_party/rules_rust/test/renamed_deps/BUILD.bazel
new file mode 100644
index 0000000..9209888
--- /dev/null
+++ b/third_party/rules_rust/test/renamed_deps/BUILD.bazel
@@ -0,0 +1,44 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "mod1",
+    srcs = ["mod1.rs"],
+)
+
+rust_library(
+    name = "mod2",
+    srcs = ["mod2.rs"],
+    deps = [":mod1"],
+)
+
+rust_library(
+    name = "mod3",
+    srcs = ["mod3.rs"],
+    aliases = {
+        ":mod1": "alias_a",
+        ":mod2": "alias_b",
+    },
+    deps = [
+        ":mod1",
+        ":mod2",
+    ],
+)
+
+rust_test(
+    name = "mod1_test",
+    crate = ":mod1",
+)
+
+rust_test(
+    name = "mod2_test",
+    crate = ":mod2",
+)
+
+rust_test(
+    name = "mod3_test",
+    aliases = {
+        ":mod1": "alias_a",
+        ":mod2": "alias_b",
+    },
+    crate = ":mod3",
+)
diff --git a/third_party/rules_rust/test/renamed_deps/mod1.rs b/third_party/rules_rust/test/renamed_deps/mod1.rs
new file mode 100644
index 0000000..a66f490
--- /dev/null
+++ b/third_party/rules_rust/test/renamed_deps/mod1.rs
@@ -0,0 +1,11 @@
+pub fn world() -> String {
+    "world".to_owned()
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_world() {
+        assert_eq!(super::world(), "world");
+    }
+}
diff --git a/third_party/rules_rust/test/renamed_deps/mod2.rs b/third_party/rules_rust/test/renamed_deps/mod2.rs
new file mode 100644
index 0000000..cff993b
--- /dev/null
+++ b/third_party/rules_rust/test/renamed_deps/mod2.rs
@@ -0,0 +1,22 @@
+extern crate mod1;
+
+pub fn greeter(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+pub fn default_greeter() -> String {
+    greeter(&mod1::world())
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_greeter() {
+        assert_eq!(super::greeter("Bob"), "Hello, Bob!");
+    }
+
+    #[test]
+    fn test_default_greeter() {
+        assert_eq!(super::default_greeter(), "Hello, world!");
+    }
+}
diff --git a/third_party/rules_rust/test/renamed_deps/mod3.rs b/third_party/rules_rust/test/renamed_deps/mod3.rs
new file mode 100644
index 0000000..4a42482
--- /dev/null
+++ b/third_party/rules_rust/test/renamed_deps/mod3.rs
@@ -0,0 +1,38 @@
+// This crate depends on 2 crates with one of them depending on the other one.
+// If the crates are not set correctly in the dependency chain, this crate won't
+// compile. The order of the `extern crate` is important to trigger that bug.
+extern crate alias_a;
+extern crate alias_b;
+
+pub fn greet(name: &str) {
+    println!("{}", alias_b::greeter(name))
+}
+
+pub fn greet_default() {
+    println!("{}", alias_b::default_greeter())
+}
+
+/// This is a documentation.
+///
+/// # Examples
+///
+/// ```rust
+/// assert!(
+///   mod3::am_i_the_world("world") == true
+/// );
+/// assert!(
+///   mod3::am_i_the_world("myself") == false
+/// );
+/// ```
+pub fn am_i_the_world(me: &str) -> bool {
+    me == alias_a::world()
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_am_i_the_world() {
+        assert!(super::am_i_the_world("world"));
+        assert!(!super::am_i_the_world("bob"));
+    }
+}
diff --git a/third_party/rules_rust/test/rust/BUILD.bazel b/third_party/rules_rust/test/rust/BUILD.bazel
new file mode 100644
index 0000000..ddb0110
--- /dev/null
+++ b/third_party/rules_rust/test/rust/BUILD.bazel
@@ -0,0 +1,17 @@
+load("//rust:defs.bzl", "rust_binary", "rust_library")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "hello_lib",
+    srcs = [
+        "src/greeter.rs",
+        "src/lib.rs",
+    ],
+)
+
+rust_binary(
+    name = "hello_world",
+    srcs = ["src/main.rs"],
+    deps = [":hello_lib"],
+)
diff --git a/third_party/rules_rust/test/rust/src/greeter.rs b/third_party/rules_rust/test/rust/src/greeter.rs
new file mode 100644
index 0000000..4a90415
--- /dev/null
+++ b/third_party/rules_rust/test/rust/src/greeter.rs
@@ -0,0 +1,75 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+/// Object that displays a greeting.
+pub struct Greeter {
+    greeting: String,
+}
+
+/// Implementation of Greeter.
+impl Greeter {
+    /// Constructs a new `Greeter`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// ```
+    pub fn new(greeting: &str) -> Greeter {
+        Greeter {
+            greeting: greeting.to_string(),
+        }
+    }
+
+    /// Returns the greeting as a string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// let greeting = greeter.greeting("World");
+    /// ```
+    pub fn greeting(&self, thing: &str) -> String {
+        format!("{} {}", &self.greeting, thing)
+    }
+
+    /// Prints the greeting.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hello_lib::greeter::Greeter;
+    ///
+    /// let greeter = Greeter::new("Hello");
+    /// greeter.greet("World");
+    /// ```
+    pub fn greet(&self, thing: &str) {
+        println!("{} {}", &self.greeting, thing);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Greeter;
+
+    #[test]
+    fn test_greeting() {
+        let hello = Greeter::new("Hi");
+        assert_eq!("Hi Rust", hello.greeting("Rust"));
+    }
+}
diff --git a/third_party/rules_rust/test/rust/src/lib.rs b/third_party/rules_rust/test/rust/src/lib.rs
new file mode 100644
index 0000000..9dc6089
--- /dev/null
+++ b/third_party/rules_rust/test/rust/src/lib.rs
@@ -0,0 +1,15 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+pub mod greeter;
diff --git a/third_party/rules_rust/test/rust/src/main.rs b/third_party/rules_rust/test/rust/src/main.rs
new file mode 100644
index 0000000..03cf43f
--- /dev/null
+++ b/third_party/rules_rust/test/rust/src/main.rs
@@ -0,0 +1,22 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate hello_lib;
+
+use hello_lib::greeter;
+
+fn main() {
+    let hello = greeter::Greeter::new("Hello");
+    hello.greet("world");
+}
diff --git a/third_party/rules_rust/test/rust_analyzer/BUILD.bazel b/third_party/rules_rust/test/rust_analyzer/BUILD.bazel
new file mode 100644
index 0000000..3132ee4
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/BUILD.bazel
@@ -0,0 +1,5 @@
+sh_binary(
+    name = "rust_analyzer_test",
+    srcs = ["rust_analyzer_test_runner.sh"],
+    args = [package_name()],
+)
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/BUILD.bazel b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/BUILD.bazel
new file mode 100644
index 0000000..2a79bbe
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/BUILD.bazel
@@ -0,0 +1,47 @@
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_proc_macro", "rust_test")
+
+rust_library(
+    name = "mylib",
+    srcs = ["mylib.rs"],
+    proc_macro_deps = [":proc_macro_dep"],
+    deps = [":lib_dep"],
+)
+
+rust_library(
+    name = "lib_dep",
+    srcs = ["lib_dep.rs"],
+)
+
+rust_proc_macro(
+    name = "proc_macro_dep",
+    srcs = ["proc_macro_dep.rs"],
+)
+
+rust_test(
+    name = "mylib_test",
+    crate = ":mylib",
+    proc_macro_deps = [":extra_proc_macro_dep"],
+    deps = [":extra_test_dep"],
+)
+
+rust_library(
+    name = "extra_test_dep",
+    srcs = ["extra_test_dep.rs"],
+)
+
+rust_proc_macro(
+    name = "extra_proc_macro_dep",
+    srcs = ["extra_proc_macro_dep.rs"],
+)
+
+rust_test(
+    name = "rust_project_json_test",
+    srcs = ["rust_project_json_test.rs"],
+    data = [":rust-project.json"],
+    edition = "2018",
+    env = {"RUST_PROJECT_JSON": "$(rootpath :rust-project.json)"},
+    # This target is tagged as manual since it's not expected to pass in
+    # contexts outside of `//test/rust_analyzer:rust_analyzer_test`. Run
+    # that target to execute this test.
+    tags = ["manual"],
+)
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_proc_macro_dep.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_proc_macro_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_proc_macro_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_test_dep.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_test_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/extra_test_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/lib_dep.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/lib_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/lib_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/mylib.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/mylib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/mylib.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/proc_macro_dep.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/proc_macro_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/proc_macro_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/rust_project_json_test.rs b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/rust_project_json_test.rs
new file mode 100644
index 0000000..b934ac2
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/aspect_traversal_test/rust_project_json_test.rs
@@ -0,0 +1,26 @@
+#[cfg(test)]
+mod tests {
+    use std::env;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_aspect_traverses_all_the_right_corners_of_target_graph() {
+        let rust_project_path = PathBuf::from(env::var("RUST_PROJECT_JSON").unwrap());
+
+        let content = std::fs::read_to_string(&rust_project_path)
+            .unwrap_or_else(|_| panic!("couldn't open {:?}", &rust_project_path));
+
+        for dep in &[
+            "lib_dep",
+            "extra_test_dep",
+            "proc_macro_dep",
+            "extra_proc_macro_dep",
+        ] {
+            assert!(
+                content.contains(dep),
+                "expected rust-project.json to contain {}.",
+                dep
+            );
+        }
+    }
+}
diff --git a/third_party/rules_rust/test/rust_analyzer/merging_crates_test/BUILD.bazel b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/BUILD.bazel
new file mode 100644
index 0000000..4a7eb3d
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/BUILD.bazel
@@ -0,0 +1,35 @@
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "mylib",
+    srcs = ["mylib.rs"],
+    deps = [":lib_dep"],
+)
+
+rust_library(
+    name = "lib_dep",
+    srcs = ["lib_dep.rs"],
+)
+
+rust_test(
+    name = "mylib_test",
+    crate = ":mylib",
+    deps = [":extra_test_dep"],
+)
+
+rust_library(
+    name = "extra_test_dep",
+    srcs = ["extra_test_dep.rs"],
+)
+
+rust_test(
+    name = "rust_project_json_test",
+    srcs = ["rust_project_json_test.rs"],
+    data = [":rust-project.json"],
+    edition = "2018",
+    env = {"RUST_PROJECT_JSON": "$(rootpath :rust-project.json)"},
+    # This target is tagged as manual since it's not expected to pass in
+    # contexts outside of `//test/rust_analyzer:rust_analyzer_test`. Run
+    # that target to execute this test.
+    tags = ["manual"],
+)
diff --git a/third_party/rules_rust/test/rust_analyzer/merging_crates_test/extra_test_dep.rs b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/extra_test_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/extra_test_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/merging_crates_test/lib_dep.rs b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/lib_dep.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/lib_dep.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/merging_crates_test/mylib.rs b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/mylib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/mylib.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/rust_analyzer/merging_crates_test/rust_project_json_test.rs b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/rust_project_json_test.rs
new file mode 100644
index 0000000..8f0db40
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/merging_crates_test/rust_project_json_test.rs
@@ -0,0 +1,17 @@
+#[cfg(test)]
+mod tests {
+    use std::env;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_deps_of_crate_and_its_test_are_merged() {
+        let rust_project_path = PathBuf::from(env::var("RUST_PROJECT_JSON").unwrap());
+
+        let content = std::fs::read_to_string(&rust_project_path)
+            .unwrap_or_else(|_| panic!("couldn't open {:?}", &rust_project_path));
+
+        assert!(
+            content.contains(r#""root_module":"mylib.rs","edition":"2018","deps":[{"crate":0,"name":"extra_test_dep"},{"crate":1,"name":"lib_dep"}]"#),
+            "expected rust-project.json to contain both lib_dep and extra_test_dep in deps of mylib.rs.");
+    }
+}
diff --git a/third_party/rules_rust/test/rust_analyzer/rust_analyzer_test_runner.sh b/third_party/rules_rust/test/rust_analyzer/rust_analyzer_test_runner.sh
new file mode 100755
index 0000000..69f9a91
--- /dev/null
+++ b/third_party/rules_rust/test/rust_analyzer/rust_analyzer_test_runner.sh
@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# This script creates temporary workspaces and generates `rust-project.json`
+# files unique to the set of targets defined in the generated workspace.
+
+set -euo pipefail
+
+if [[ -z "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then
+    echo "This script should be run under Bazel"
+    exit 1
+fi
+
+PACKAGE_NAME="$1"
+if [[ -z "${PACKAGE_NAME:-}" ]]; then
+    echo "The first argument should be the package name of the test target"
+    exit 1
+fi
+
+function generate_workspace() {
+    local temp_dir="$(mktemp -d -t rules_rust_test_rust_analyzer-XXXXXXXXXX)"
+    local new_workspace="${temp_dir}/rules_rust_test_rust_analyzer"
+
+    mkdir -p "${new_workspace}"
+    cat << EOF > "${new_workspace}/WORKSPACE.bazel"
+workspace(name = "rules_rust_test_rust_analyzer")
+local_repository(
+    name = "rules_rust",
+    path = "${BUILD_WORKSPACE_DIRECTORY}",
+)
+load("@rules_rust//rust:repositories.bzl", "rust_repositories")
+rust_repositories(include_rustc_srcs = True)
+load("@rules_rust//tools/rust_analyzer:deps.bzl", "rust_analyzer_deps")
+rust_analyzer_deps()
+EOF
+
+cat << EOF > "${new_workspace}/.bazelrc"
+build --keep_going
+test --test_output=errors
+# The 'strict' config is used to ensure extra checks are run on the test
+# targets that would otherwise not run due to them being tagged as "manual".
+# Note that that tag is stripped for this test.
+build:strict --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:strict --output_groups=+rustfmt_checks
+build:strict --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:strict --output_groups=+clippy_checks
+EOF
+
+  echo "${new_workspace}"
+}
+
+function rust_analyzer_test() {
+    local source_dir="$1"
+    local workspace="$2"
+    
+    echo "Testing '$(basename "${source_dir}")'"
+    rm -f "${workspace}"/*.rs "${workspace}"/*.json "${workspace}/BUILD.bazel"
+    cp -r "${source_dir}"/* "${workspace}"
+    
+    # Drop the 'manual' tags
+    if [ "$(uname)" == "Darwin" ]; then
+        SEDOPTS=(-i '' -e)
+    else
+        SEDOPTS=(-i)
+    fi
+    sed ${SEDOPTS[@]} 's/"manual"//' "${workspace}/BUILD.bazel"
+    
+    pushd "${workspace}" &> /dev/null
+    echo "Generating rust-project.json..."
+    bazel run "@rules_rust//tools/rust_analyzer:gen_rust_project"
+    echo "Building..."
+    bazel build //...
+    echo "Testing..."
+    bazel test //...
+    echo "Building with Aspects..."
+    bazel build //... --config=strict
+    popd &> /dev/null
+}
+
+function run_test_suite() {
+    local temp_workspace="$(generate_workspace)"
+    echo "Generated workspace: ${temp_workspace}"
+
+    for test_dir in "${BUILD_WORKSPACE_DIRECTORY}/${PACKAGE_NAME}"/*; do
+        # Skip everything but directories
+        if [[ ! -d "${test_dir}" ]]; then
+            continue
+        fi
+
+        rust_analyzer_test "${test_dir}" "${temp_workspace}"
+    done
+
+    rm -rf "${temp_workspace}"
+}
+
+run_test_suite
diff --git a/third_party/rules_rust/test/rust_test_suite/BUILD.bazel b/third_party/rules_rust/test/rust_test_suite/BUILD.bazel
new file mode 100644
index 0000000..8490f8b
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/BUILD.bazel
@@ -0,0 +1,14 @@
+load("//rust:defs.bzl", "rust_library", "rust_test_suite")
+
+rust_library(
+    name = "math_lib",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+)
+
+rust_test_suite(
+    name = "integrated_tests_suite",
+    srcs = glob(["tests/**"]),
+    edition = "2018",
+    deps = [":math_lib"],
+)
diff --git a/third_party/rules_rust/test/rust_test_suite/src/lib.rs b/third_party/rules_rust/test/rust_test_suite/src/lib.rs
new file mode 100644
index 0000000..05a141c
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/src/lib.rs
@@ -0,0 +1,14 @@
+/// A function that adds two numbers
+pub fn add(a: i32, b: i32) -> i32 {
+    // This line adds two i32's
+    a + b
+}
+
+/// Calculate the n'th fibonacci number
+pub fn fibonacci(n: i32) -> i32 {
+    match n {
+        0 => 1,
+        1 => 1,
+        _ => fibonacci(n - 1) + fibonacci(n - 2),
+    }
+}
diff --git a/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_a.rs b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_a.rs
new file mode 100644
index 0000000..d5c4069
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_a.rs
@@ -0,0 +1,6 @@
+use math_lib::add;
+
+#[test]
+fn add_one_and_two() {
+    assert_eq!(add(1, 2), 3);
+}
diff --git a/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_b.rs b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_b.rs
new file mode 100644
index 0000000..4b1c3f6
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_b.rs
@@ -0,0 +1,6 @@
+use math_lib::add;
+
+#[test]
+fn add_three_and_four() {
+    assert_eq!(add(3, 4), 7);
+}
diff --git a/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_c.rs b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_c.rs
new file mode 100644
index 0000000..5104b3d
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/tests/integrated_test_c.rs
@@ -0,0 +1,6 @@
+use math_lib::add;
+
+#[test]
+fn add_five_and_six() {
+    assert_eq!(add(5, 6), 11);
+}
diff --git a/third_party/rules_rust/test/rust_test_suite/tests/patterns/fibonacci_test.rs b/third_party/rules_rust/test/rust_test_suite/tests/patterns/fibonacci_test.rs
new file mode 100644
index 0000000..5b74834
--- /dev/null
+++ b/third_party/rules_rust/test/rust_test_suite/tests/patterns/fibonacci_test.rs
@@ -0,0 +1,6 @@
+use math_lib::fibonacci;
+
+#[test]
+fn fibonacci_test() {
+    assert_eq!(fibonacci(6), 13);
+}
diff --git a/third_party/rules_rust/test/rustc_env_files/BUILD.bazel b/third_party/rules_rust/test/rustc_env_files/BUILD.bazel
new file mode 100644
index 0000000..431cd07
--- /dev/null
+++ b/third_party/rules_rust/test/rustc_env_files/BUILD.bazel
@@ -0,0 +1,22 @@
+load("//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "hello_env",
+    srcs = ["src/main.rs"],
+    rustc_env_files = [":generate_rustc_env_file"],
+)
+
+genrule(
+    name = "generate_rustc_env_file",
+    outs = ["rustc_env_file"],
+    cmd = "echo CARGO_PKG_VERSION=1.2.3 >> $@ && echo GREETING=Howdy >> $@",
+)
+
+sh_test(
+    name = "output_test",
+    srcs = ["output_test.sh"],
+    args = ["$(location :hello_env)"],
+    data = [":hello_env"],
+)
diff --git a/third_party/rules_rust/test/rustc_env_files/output_test.sh b/third_party/rules_rust/test/rustc_env_files/output_test.sh
new file mode 100755
index 0000000..9bb91fe
--- /dev/null
+++ b/third_party/rules_rust/test/rustc_env_files/output_test.sh
@@ -0,0 +1,6 @@
+#!/bin/bash -eu
+
+set -o pipefail
+
+output="$($1)"
+[[ "${output}" == "Howdy from version 1.2.3" ]] || { echo >&2 "Unexpected output: ${output}"; exit 1;}
diff --git a/third_party/rules_rust/test/rustc_env_files/src/main.rs b/third_party/rules_rust/test/rustc_env_files/src/main.rs
new file mode 100644
index 0000000..4f3de6b
--- /dev/null
+++ b/third_party/rules_rust/test/rustc_env_files/src/main.rs
@@ -0,0 +1,21 @@
+// Copyright 2021 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+fn main() {
+    println!(
+        "{} from version {}",
+        env!("GREETING"),
+        env!("CARGO_PKG_VERSION")
+    );
+}
diff --git a/third_party/rules_rust/test/rustfmt/BUILD.bazel b/third_party/rules_rust/test/rustfmt/BUILD.bazel
new file mode 100644
index 0000000..37920f0
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/BUILD.bazel
@@ -0,0 +1,58 @@
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rustfmt_test")
+
+exports_files([
+    "test_rustfmt.toml",
+])
+
+rust_binary(
+    name = "formatted_2018",
+    srcs = ["srcs/2018/formatted.rs"],
+    edition = "2018",
+)
+
+rustfmt_test(
+    name = "test_formatted_2018",
+    targets = [":formatted_2018"],
+)
+
+rust_binary(
+    name = "unformatted_2018",
+    srcs = ["srcs/2018/unformatted.rs"],
+    edition = "2018",
+    tags = ["norustfmt"],
+)
+
+rustfmt_test(
+    name = "test_unformatted_2018",
+    tags = ["manual"],
+    targets = [":unformatted_2018"],
+)
+
+rust_binary(
+    name = "formatted_2015",
+    srcs = ["srcs/2015/formatted.rs"],
+    edition = "2015",
+)
+
+rustfmt_test(
+    name = "test_formatted_2015",
+    targets = [":formatted_2015"],
+)
+
+rust_binary(
+    name = "unformatted_2015",
+    srcs = ["srcs/2015/unformatted.rs"],
+    edition = "2015",
+    tags = ["norustfmt"],
+)
+
+rustfmt_test(
+    name = "test_unformatted_2015",
+    tags = ["manual"],
+    targets = [":unformatted_2015"],
+)
+
+sh_binary(
+    name = "test_runner",
+    srcs = ["rustfmt_failure_test.sh"],
+)
diff --git a/third_party/rules_rust/test/rustfmt/rustfmt_failure_test.sh b/third_party/rules_rust/test/rustfmt/rustfmt_failure_test.sh
new file mode 100755
index 0000000..7fc56da
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/rustfmt_failure_test.sh
@@ -0,0 +1,91 @@
+#!/bin/bash
+
+# Runs Bazel build commands over rustfmt rules, where some are expected
+# to fail.
+#
+# Can be run from anywhere within the rules_rust workspace.
+
+set -euo pipefail
+
+if [[ -z "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then
+  echo "This script should be run under Bazel"
+  exit 1
+fi
+
+cd "${BUILD_WORKSPACE_DIRECTORY}"
+
+# Executes a bazel build command and handles the return value, exiting
+# upon seeing an error.
+#
+# Takes two arguments:
+# ${1}: The expected return code.
+# ${2}: The target within "//test/rustfmt" to be tested.
+function check_build_result() {
+  local ret=0
+  echo -n "Testing ${2}... "
+  (bazel test //test/rustfmt:"${2}" &> /dev/null) || ret="$?" && true
+  if [[ "${ret}" -ne "${1}" ]]; then
+    echo "FAIL: Unexpected return code [saw: ${ret}, want: ${1}] building target //test/rustfmt:${2}"
+    echo "  Run \"bazel test //test/rustfmt:${2}\" to see the output"
+    exit 1
+  else
+    echo "OK"
+  fi
+}
+
+function test_all_and_apply() {
+  local -r TEST_OK=0
+  local -r TEST_FAILED=3
+
+  temp_dir="$(mktemp -d -t ci-XXXXXXXXXX)"
+  new_workspace="${temp_dir}/rules_rust_test_rustfmt"
+  
+  mkdir -p "${new_workspace}/test/rustfmt" && \
+  cp -r test/rustfmt/* "${new_workspace}/test/rustfmt/" && \
+  cat << EOF > "${new_workspace}/WORKSPACE.bazel"
+workspace(name = "rules_rust_test_rustfmt")
+local_repository(
+    name = "rules_rust",
+    path = "${BUILD_WORKSPACE_DIRECTORY}",
+)
+load("@rules_rust//rust:repositories.bzl", "rust_repositories")
+rust_repositories()
+EOF
+
+  # Drop the 'norustfmt' tags
+  if [ "$(uname)" == "Darwin" ]; then
+    SEDOPTS=(-i '' -e)
+  else
+    SEDOPTS=(-i)
+  fi
+  sed ${SEDOPTS[@]} 's/"norustfmt"//' "${new_workspace}/test/rustfmt/BUILD.bazel"
+
+  pushd "${new_workspace}"
+
+  check_build_result $TEST_FAILED test_unformatted_2015
+  check_build_result $TEST_FAILED test_unformatted_2018
+  check_build_result $TEST_OK test_formatted_2015
+  check_build_result $TEST_OK test_formatted_2018
+
+  # Format a specific target
+  bazel run @rules_rust//tools/rustfmt -- //test/rustfmt:unformatted_2018
+
+  check_build_result $TEST_FAILED test_unformatted_2015
+  check_build_result $TEST_OK test_unformatted_2018
+  check_build_result $TEST_OK test_formatted_2015
+  check_build_result $TEST_OK test_formatted_2018
+
+  # Format all targets
+  bazel run @rules_rust//tools/rustfmt --@rules_rust//:rustfmt.toml=//test/rustfmt:test_rustfmt.toml
+
+  check_build_result $TEST_OK test_unformatted_2015
+  check_build_result $TEST_OK test_unformatted_2018
+  check_build_result $TEST_OK test_formatted_2015
+  check_build_result $TEST_OK test_formatted_2018
+
+  popd
+
+  rm -rf "${temp_dir}"
+}
+
+test_all_and_apply
diff --git a/third_party/rules_rust/test/rustfmt/srcs/2015/formatted.rs b/third_party/rules_rust/test/rustfmt/srcs/2015/formatted.rs
new file mode 100644
index 0000000..a204013
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/srcs/2015/formatted.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("2015");
+}
diff --git a/third_party/rules_rust/test/rustfmt/srcs/2015/unformatted.rs b/third_party/rules_rust/test/rustfmt/srcs/2015/unformatted.rs
new file mode 100644
index 0000000..d6e473f
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/srcs/2015/unformatted.rs
@@ -0,0 +1 @@
+fn main(){println!("2015");}
diff --git a/third_party/rules_rust/test/rustfmt/srcs/2018/formatted.rs b/third_party/rules_rust/test/rustfmt/srcs/2018/formatted.rs
new file mode 100644
index 0000000..dff90f2
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/srcs/2018/formatted.rs
@@ -0,0 +1,40 @@
+use std::future::Future;
+use std::sync::Arc;
+use std::task::{Context, Poll, Wake};
+use std::thread::{self, Thread};
+
+/// A waker that wakes up the current thread when called.
+struct ThreadWaker(Thread);
+
+impl Wake for ThreadWaker {
+    fn wake(self: Arc<Self>) {
+        self.0.unpark();
+    }
+}
+
+/// Run a future to completion on the current thread.
+fn block_on<T>(fut: impl Future<Output = T>) -> T {
+    // Pin the future so it can be polled.
+    let mut fut = Box::pin(fut);
+
+    // Create a new context to be passed to the future.
+    let t = thread::current();
+    let waker = Arc::new(ThreadWaker(t)).into();
+    let mut cx = Context::from_waker(&waker);
+
+    // Run the future to completion.
+    loop {
+        match fut.as_mut().poll(&mut cx) {
+            Poll::Ready(res) => return res,
+            Poll::Pending => thread::park(),
+        }
+    }
+}
+
+async fn edition() -> i32 {
+    2018
+}
+
+fn main() {
+    println!("{}", block_on(edition()));
+}
diff --git a/third_party/rules_rust/test/rustfmt/srcs/2018/unformatted.rs b/third_party/rules_rust/test/rustfmt/srcs/2018/unformatted.rs
new file mode 100644
index 0000000..454ac49
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/srcs/2018/unformatted.rs
@@ -0,0 +1,19 @@
+use std::future::Future; use std::sync::Arc; use std::task::{Context, Poll, Wake}; use std::thread::{self, Thread};
+/// A waker that wakes up the current thread when called.
+struct ThreadWaker(Thread);
+impl Wake for ThreadWaker {fn wake(self: Arc<Self>) {self.0.unpark();}}
+/// Run a future to completion on the current thread.
+fn block_on<T>(fut: impl Future<Output = T>) -> T {
+// Pin the future so it can be polled.
+let mut fut = Box::pin(fut);
+// Create a new context to be passed to the future.
+let t = thread::current();let waker = Arc::new(ThreadWaker(t)).into();
+let mut cx = Context::from_waker(&waker);
+// Run the future to completion.
+loop {match fut.as_mut().poll(&mut cx) {
+Poll::Ready(res) => return res, Poll::Pending => thread::park(),
+}
+}
+}
+async fn edition() -> i32 {2018}
+fn main(){println!("{}", block_on(edition()));}
diff --git a/third_party/rules_rust/test/rustfmt/test_rustfmt.toml b/third_party/rules_rust/test/rustfmt/test_rustfmt.toml
new file mode 100644
index 0000000..ac5d99f
--- /dev/null
+++ b/third_party/rules_rust/test/rustfmt/test_rustfmt.toml
@@ -0,0 +1 @@
+control_brace_style = "AlwaysNextLine"
diff --git a/third_party/rules_rust/test/test_env/BUILD.bazel b/third_party/rules_rust/test/test_env/BUILD.bazel
new file mode 100644
index 0000000..623230f
--- /dev/null
+++ b/third_party/rules_rust/test/test_env/BUILD.bazel
@@ -0,0 +1,26 @@
+load("//rust:defs.bzl", "rust_binary", "rust_test")
+
+rust_binary(
+    name = "hello-world",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+)
+
+filegroup(
+    name = "hello_world_main",
+    srcs = ["src/main.rs"],
+)
+
+rust_test(
+    name = "test",
+    srcs = ["tests/run.rs"],
+    data = [
+        ":hello-world",
+        ":hello_world_main",
+    ],
+    edition = "2018",
+    env = {
+        "FERRIS_SAYS": "Hello fellow Rustaceans!",
+        "HELLO_WORLD_BIN_ROOTPATH": "$(rootpath :hello-world)",
+    },
+)
diff --git a/third_party/rules_rust/test/test_env/src/main.rs b/third_party/rules_rust/test/test_env/src/main.rs
new file mode 100644
index 0000000..5bf256e
--- /dev/null
+++ b/third_party/rules_rust/test/test_env/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello world");
+}
diff --git a/third_party/rules_rust/test/test_env/tests/run.rs b/third_party/rules_rust/test/test_env/tests/run.rs
new file mode 100644
index 0000000..1c78412
--- /dev/null
+++ b/third_party/rules_rust/test/test_env/tests/run.rs
@@ -0,0 +1,29 @@
+#[test]
+fn run() {
+    let path = env!("CARGO_BIN_EXE_hello-world");
+    let output = std::process::Command::new(path)
+        .output()
+        .expect("Failed to run process");
+    assert_eq!(&b"Hello world\n"[..], output.stdout.as_slice());
+
+    // Test the `env` attribute of `rust_test` at run time
+    assert_eq!(
+        std::env::var("FERRIS_SAYS").unwrap(),
+        "Hello fellow Rustaceans!"
+    );
+
+    // Test the behavior of `rootpath` and that a binary can be found relative to current_dir
+    let hello_world_bin =
+        std::path::PathBuf::from(std::env::var_os("HELLO_WORLD_BIN_ROOTPATH").unwrap());
+
+    assert_eq!(
+        hello_world_bin.as_path(),
+        std::path::Path::new(if std::env::consts::OS == "windows" {
+            "test/test_env/hello-world.exe"
+        } else {
+            "test/test_env/hello-world"
+        })
+    );
+    assert!(!hello_world_bin.is_absolute());
+    assert!(hello_world_bin.exists());
+}
diff --git a/third_party/rules_rust/test/test_env_launcher/BUILD.bazel b/third_party/rules_rust/test/test_env_launcher/BUILD.bazel
new file mode 100644
index 0000000..f2fe852
--- /dev/null
+++ b/third_party/rules_rust/test/test_env_launcher/BUILD.bazel
@@ -0,0 +1,27 @@
+load("//rust:defs.bzl", "rust_binary", "rust_test")
+
+rust_binary(
+    name = "hello-world",
+    srcs = ["src/main.rs"],
+    edition = "2018",
+)
+
+filegroup(
+    name = "hello_world_main",
+    srcs = ["src/main.rs"],
+)
+
+rust_test(
+    name = "test",
+    srcs = ["tests/run.rs"],
+    data = [
+        ":hello-world",
+        ":hello_world_main",
+    ],
+    edition = "2018",
+    env = {
+        "FERRIS_SAYS": "Hello fellow Rustaceans!",
+        "HELLO_WORLD_BIN": "$(rootpath :hello-world)",
+        "HELLO_WORLD_SRC": "$(rootpath :hello_world_main)",
+    },
+)
diff --git a/third_party/rules_rust/test/test_env_launcher/src/main.rs b/third_party/rules_rust/test/test_env_launcher/src/main.rs
new file mode 100644
index 0000000..5bf256e
--- /dev/null
+++ b/third_party/rules_rust/test/test_env_launcher/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello world");
+}
diff --git a/third_party/rules_rust/test/test_env_launcher/tests/run.rs b/third_party/rules_rust/test/test_env_launcher/tests/run.rs
new file mode 100644
index 0000000..7089671
--- /dev/null
+++ b/third_party/rules_rust/test/test_env_launcher/tests/run.rs
@@ -0,0 +1,33 @@
+#[test]
+fn run() {
+    let path = env!("CARGO_BIN_EXE_hello-world");
+    let output = std::process::Command::new(path)
+        .output()
+        .expect("Failed to run process");
+    assert_eq!(&b"Hello world\n"[..], output.stdout.as_slice());
+
+    // Test the `env` attribute of `rust_test` at run time
+    assert_eq!(
+        std::env::var("FERRIS_SAYS").unwrap(),
+        "Hello fellow Rustaceans!"
+    );
+
+    // Test the behavior of `rootpath` and that a binary can be found relative to current_dir
+    let hello_world_bin = std::path::PathBuf::from(std::env::var_os("HELLO_WORLD_BIN").unwrap());
+
+    assert_eq!(
+        hello_world_bin.as_path(),
+        std::path::Path::new(if std::env::consts::OS == "windows" {
+            "test/test_env_launcher/hello-world.exe"
+        } else {
+            "test/test_env_launcher/hello-world"
+        })
+    );
+    assert!(!hello_world_bin.is_absolute());
+    assert!(hello_world_bin.exists());
+
+    // Ensure `execpath` expanded variables map to real files and have absolute paths
+    let hello_world_src = std::path::PathBuf::from(std::env::var("HELLO_WORLD_SRC").unwrap());
+    assert!(!hello_world_bin.is_absolute());
+    assert!(hello_world_src.exists());
+}
diff --git a/third_party/rules_rust/test/transitive_lib/BUILD.bazel b/third_party/rules_rust/test/transitive_lib/BUILD.bazel
new file mode 100644
index 0000000..b745248
--- /dev/null
+++ b/third_party/rules_rust/test/transitive_lib/BUILD.bazel
@@ -0,0 +1,30 @@
+load("//cargo:cargo_build_script.bzl", "cargo_build_script")
+load("//rust:defs.bzl", "rust_binary", "rust_library")
+
+# sets link alias
+cargo_build_script(
+    name = "buildscript",
+    srcs = ["build.rs"],
+    crate_root = "build.rs",
+    edition = "2018",
+)
+
+# links to a symbol in shell32
+rust_library(
+    name = "dll_user",
+    srcs = ["dll_user.rs"],
+    edition = "2018",
+    deps = [
+        ":buildscript",
+    ],
+)
+
+# does not link to any symbol in shell32
+rust_binary(
+    name = "dll_user_user",
+    srcs = ["dll_user_user.rs"],
+    edition = "2018",
+    deps = [
+        ":dll_user",
+    ],
+)
diff --git a/third_party/rules_rust/test/transitive_lib/build.rs b/third_party/rules_rust/test/transitive_lib/build.rs
new file mode 100644
index 0000000..90b5a12
--- /dev/null
+++ b/third_party/rules_rust/test/transitive_lib/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("cargo:rustc-link-lib=alias:shell32");
+}
diff --git a/third_party/rules_rust/test/transitive_lib/dll_user.rs b/third_party/rules_rust/test/transitive_lib/dll_user.rs
new file mode 100644
index 0000000..890590f
--- /dev/null
+++ b/third_party/rules_rust/test/transitive_lib/dll_user.rs
@@ -0,0 +1,5 @@
+#[link(name = "alias")]
+extern "C" {
+    // random symbol from shell32
+    pub fn LocalFree(ptr: *mut std::os::raw::c_void);
+}
diff --git a/third_party/rules_rust/test/transitive_lib/dll_user_user.rs b/third_party/rules_rust/test/transitive_lib/dll_user_user.rs
new file mode 100644
index 0000000..5756760
--- /dev/null
+++ b/third_party/rules_rust/test/transitive_lib/dll_user_user.rs
@@ -0,0 +1,5 @@
+fn main() {
+    // this file does not link to any shell32 symbols directly, and
+    // will thus cause a compile error if -lalias:shell32
+    // is present in the link flags
+}
diff --git a/third_party/rules_rust/test/unit/BUILD.bazel b/third_party/rules_rust/test/unit/BUILD.bazel
new file mode 100644
index 0000000..433344f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/BUILD.bazel
@@ -0,0 +1,5 @@
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "common.bzl",
+])
diff --git a/third_party/rules_rust/test/unit/cc_info/BUILD.bazel b/third_party/rules_rust/test/unit/cc_info/BUILD.bazel
new file mode 100644
index 0000000..425bb37
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cc_info/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":cc_info_test.bzl", "cc_info_test_suite")
+
+############################ UNIT TESTS #############################
+cc_info_test_suite(name = "cc_info_test_suite")
diff --git a/third_party/rules_rust/test/unit/cc_info/bin_using_native_dep.rs b/third_party/rules_rust/test/unit/cc_info/bin_using_native_dep.rs
new file mode 100644
index 0000000..b128c4f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cc_info/bin_using_native_dep.rs
@@ -0,0 +1,6 @@
+extern "C" {
+    fn native_dep() -> isize;
+}
+fn main() {
+    println!("{}", unsafe { native_dep() })
+}
diff --git a/third_party/rules_rust/test/unit/cc_info/cc_info_test.bzl b/third_party/rules_rust/test/unit/cc_info/cc_info_test.bzl
new file mode 100644
index 0000000..9873a1f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cc_info/cc_info_test.bzl
@@ -0,0 +1,181 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_proc_macro", "rust_shared_library", "rust_static_library")
+
+def _is_dylib_on_windows(ctx):
+    return ctx.target_platform_has_constraint(ctx.attr._windows[platform_common.ConstraintValueInfo])
+
+def _assert_cc_info_has_library_to_link(env, tut, type, ccinfo_count):
+    asserts.true(env, CcInfo in tut, "rust_library should provide CcInfo")
+    cc_info = tut[CcInfo]
+    linker_inputs = cc_info.linking_context.linker_inputs.to_list()
+    asserts.equals(env, ccinfo_count, len(linker_inputs))
+    library_to_link = linker_inputs[0].libraries[0]
+    asserts.equals(env, False, library_to_link.alwayslink)
+
+    asserts.equals(env, [], library_to_link.lto_bitcode_files)
+    asserts.equals(env, [], library_to_link.pic_lto_bitcode_files)
+
+    asserts.equals(env, [], library_to_link.objects)
+    asserts.equals(env, [], library_to_link.pic_objects)
+
+    if type == "cdylib":
+        asserts.true(env, library_to_link.dynamic_library != None)
+        if _is_dylib_on_windows(env.ctx):
+            asserts.true(env, library_to_link.interface_library != None)
+            asserts.true(env, library_to_link.resolved_symlink_dynamic_library == None)
+        else:
+            asserts.equals(env, None, library_to_link.interface_library)
+            asserts.true(env, library_to_link.resolved_symlink_dynamic_library != None)
+        asserts.equals(env, None, library_to_link.resolved_symlink_interface_library)
+        asserts.equals(env, None, library_to_link.static_library)
+        asserts.equals(env, None, library_to_link.pic_static_library)
+    else:
+        asserts.equals(env, None, library_to_link.dynamic_library)
+        asserts.equals(env, None, library_to_link.interface_library)
+        asserts.equals(env, None, library_to_link.resolved_symlink_dynamic_library)
+        asserts.equals(env, None, library_to_link.resolved_symlink_interface_library)
+        asserts.true(env, library_to_link.static_library != None)
+        if type in ("rlib", "lib"):
+            asserts.true(env, library_to_link.static_library.basename.startswith("lib" + tut.label.name))
+        asserts.true(env, library_to_link.pic_static_library != None)
+        asserts.equals(env, library_to_link.static_library, library_to_link.pic_static_library)
+
+def _collect_user_link_flags(env, tut):
+    asserts.true(env, CcInfo in tut, "rust_library should provide CcInfo")
+    cc_info = tut[CcInfo]
+    linker_inputs = cc_info.linking_context.linker_inputs.to_list()
+    return [f for i in linker_inputs for f in i.user_link_flags]
+
+def _rlib_provides_cc_info_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    _assert_cc_info_has_library_to_link(env, tut, "rlib", 3)
+    return analysistest.end(env)
+
+def _rlib_with_dep_only_has_stdlib_linkflags_once_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    user_link_flags = _collect_user_link_flags(env, tut)
+    asserts.equals(
+        env,
+        depset(user_link_flags).to_list(),
+        user_link_flags,
+        "user_link_flags_should_not_have_duplicates_here",
+    )
+    return analysistest.end(env)
+
+def _bin_does_not_provide_cc_info_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    asserts.false(env, CcInfo in tut, "rust_binary should not provide CcInfo")
+    return analysistest.end(env)
+
+def _proc_macro_does_not_provide_cc_info_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    asserts.false(env, CcInfo in tut, "rust_proc_macro should not provide CcInfo")
+    return analysistest.end(env)
+
+def _cdylib_provides_cc_info_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    _assert_cc_info_has_library_to_link(env, tut, "cdylib", 2)
+    return analysistest.end(env)
+
+def _staticlib_provides_cc_info_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    _assert_cc_info_has_library_to_link(env, tut, "staticlib", 2)
+    return analysistest.end(env)
+
+rlib_provides_cc_info_test = analysistest.make(_rlib_provides_cc_info_test_impl)
+rlib_with_dep_only_has_stdlib_linkflags_once_test = analysistest.make(
+    _rlib_with_dep_only_has_stdlib_linkflags_once_test_impl,
+)
+bin_does_not_provide_cc_info_test = analysistest.make(_bin_does_not_provide_cc_info_test_impl)
+staticlib_provides_cc_info_test = analysistest.make(_staticlib_provides_cc_info_test_impl)
+cdylib_provides_cc_info_test = analysistest.make(_cdylib_provides_cc_info_test_impl, attrs = {
+    "_windows": attr.label(default = Label("@platforms//os:windows")),
+})
+proc_macro_does_not_provide_cc_info_test = analysistest.make(_proc_macro_does_not_provide_cc_info_test_impl)
+
+def _cc_info_test():
+    rust_library(
+        name = "rlib",
+        srcs = ["foo.rs"],
+    )
+
+    rust_library(
+        name = "rlib_with_dep",
+        srcs = ["foo.rs"],
+        deps = [":rlib"],
+    )
+
+    rust_binary(
+        name = "bin",
+        srcs = ["foo.rs"],
+    )
+
+    rust_static_library(
+        name = "staticlib",
+        srcs = ["foo.rs"],
+    )
+
+    rust_shared_library(
+        name = "cdylib",
+        srcs = ["foo.rs"],
+    )
+
+    rust_proc_macro(
+        name = "proc_macro",
+        srcs = ["proc_macro.rs"],
+        edition = "2018",
+        deps = ["//test/unit/native_deps:native_dep"],
+    )
+
+    rlib_provides_cc_info_test(
+        name = "rlib_provides_cc_info_test",
+        target_under_test = ":rlib",
+    )
+    rlib_with_dep_only_has_stdlib_linkflags_once_test(
+        name = "rlib_with_dep_only_has_stdlib_linkflags_once_test",
+        target_under_test = ":rlib_with_dep",
+    )
+    bin_does_not_provide_cc_info_test(
+        name = "bin_does_not_provide_cc_info_test",
+        target_under_test = ":bin",
+    )
+    cdylib_provides_cc_info_test(
+        name = "cdylib_provides_cc_info_test",
+        target_under_test = ":cdylib",
+    )
+    staticlib_provides_cc_info_test(
+        name = "staticlib_provides_cc_info_test",
+        target_under_test = ":staticlib",
+    )
+    proc_macro_does_not_provide_cc_info_test(
+        name = "proc_macro_does_not_provide_cc_info_test",
+        target_under_test = ":proc_macro",
+    )
+
+def cc_info_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _cc_info_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":rlib_provides_cc_info_test",
+            ":rlib_with_dep_only_has_stdlib_linkflags_once_test",
+            ":staticlib_provides_cc_info_test",
+            ":cdylib_provides_cc_info_test",
+            ":proc_macro_does_not_provide_cc_info_test",
+            ":bin_does_not_provide_cc_info_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/cc_info/foo.rs b/third_party/rules_rust/test/unit/cc_info/foo.rs
new file mode 100644
index 0000000..20e63e3
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cc_info/foo.rs
@@ -0,0 +1,3 @@
+pub fn main() {
+    dbg!(42);
+}
diff --git a/third_party/rules_rust/test/unit/cc_info/proc_macro.rs b/third_party/rules_rust/test/unit/cc_info/proc_macro.rs
new file mode 100644
index 0000000..fc2bac8
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cc_info/proc_macro.rs
@@ -0,0 +1,11 @@
+use proc_macro::TokenStream;
+
+extern "C" {
+    fn native_dep() -> isize;
+}
+
+#[proc_macro_derive(UsingNativeDep)]
+pub fn use_native_dep(input: TokenStream) -> TokenStream {
+    println!("{}", unsafe { native_dep() });
+    input
+}
diff --git a/third_party/rules_rust/test/unit/cdylib_name/BUILD.bazel b/third_party/rules_rust/test/unit/cdylib_name/BUILD.bazel
new file mode 100644
index 0000000..112a7da
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cdylib_name/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":cdylib_name_analysis_test.bzl", "cdylib_name_analysis_test_suite")
+
+############################ UNIT TESTS #############################
+cdylib_name_analysis_test_suite(name = "cdylib_name_analysis_test_suite")
diff --git a/third_party/rules_rust/test/unit/cdylib_name/cdylib_name_analysis_test.bzl b/third_party/rules_rust/test/unit/cdylib_name/cdylib_name_analysis_test.bzl
new file mode 100644
index 0000000..7aefdda
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cdylib_name/cdylib_name_analysis_test.bzl
@@ -0,0 +1,48 @@
+"""Analysis tests for the name we assign to cdylib libraries."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_shared_library")
+
+def _cdylib_name_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    # We're expecting the `.dylib`/`.so` to be the only file on Unix and Windows to
+    # contain a pair of `.dll` and `.lib` files.
+    files = target[DefaultInfo].files.to_list()
+    if len(files) == 1:
+        asserts.true(env, files[0].extension in ("so", "dylib"))
+        if files[0].extension == "so":
+            asserts.equals(env, files[0].basename, "libsomething.so")
+        elif files[0].extension == "dylib":
+            asserts.equals(env, files[0].basename, "libsomething.dylib")
+    elif len(files) == 2:
+        expected_filenames = ["something.dll", "something.dll.lib"]
+        for file in files:
+            asserts.true(env, file.basename in expected_filenames)
+            expected_filenames.remove(file.basename)
+
+    return analysistest.end(env)
+
+cdylib_name_test = analysistest.make(_cdylib_name_test_impl)
+
+def cdylib_name_analysis_test_suite(name):
+    """Analysis tests for the name we assign to cdylib libraries.
+
+    Args:
+        name: the test suite name
+    """
+    rust_shared_library(
+        name = "something",
+        srcs = ["lib.rs"],
+    )
+
+    cdylib_name_test(
+        name = "cdylib_name_test",
+        target_under_test = ":something",
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [":cdylib_name_test"],
+    )
diff --git a/third_party/rules_rust/test/unit/cdylib_name/lib.rs b/third_party/rules_rust/test/unit/cdylib_name/lib.rs
new file mode 100644
index 0000000..417c1ba
--- /dev/null
+++ b/third_party/rules_rust/test/unit/cdylib_name/lib.rs
@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn say_hello() {
+    println!("Hello");
+}
diff --git a/third_party/rules_rust/test/unit/check_runfiles/BUILD.bazel b/third_party/rules_rust/test/unit/check_runfiles/BUILD.bazel
new file mode 100644
index 0000000..0dfcfcc
--- /dev/null
+++ b/third_party/rules_rust/test/unit/check_runfiles/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":check_runfiles_test.bzl", "check_runfiles_test_suite")
+
+############################ UNIT TESTS #############################
+check_runfiles_test_suite(name = "check_runfiles_test_suite")
diff --git a/third_party/rules_rust/test/unit/check_runfiles/bar.cc b/third_party/rules_rust/test/unit/check_runfiles/bar.cc
new file mode 100644
index 0000000..237c8ce
--- /dev/null
+++ b/third_party/rules_rust/test/unit/check_runfiles/bar.cc
@@ -0,0 +1 @@
+int main() {}
diff --git a/third_party/rules_rust/test/unit/check_runfiles/check_runfiles_test.bzl b/third_party/rules_rust/test/unit/check_runfiles/check_runfiles_test.bzl
new file mode 100644
index 0000000..94ee3d7
--- /dev/null
+++ b/third_party/rules_rust/test/unit/check_runfiles/check_runfiles_test.bzl
@@ -0,0 +1,97 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load(
+    "//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_shared_library",
+    "rust_static_library",
+)
+
+def _check_runfiles_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    runfiles = tut[DefaultInfo].default_runfiles.files.to_list()
+
+    asserts.true(env, _is_in_runfiles("libbar.so", runfiles))
+
+    return analysistest.end(env)
+
+def _is_in_runfiles(name, runfiles):
+    for file in runfiles:
+        if file.basename == name:
+            return True
+    return False
+
+check_runfiles_test = analysistest.make(_check_runfiles_test_impl)
+
+def _check_runfiles_test():
+    rust_library(
+        name = "foo_lib",
+        srcs = ["foo.rs"],
+        deps = [":libbar.so"],
+    )
+
+    rust_binary(
+        name = "foo_bin",
+        srcs = ["foo_main.rs"],
+        deps = [":libbar.so"],
+    )
+
+    rust_shared_library(
+        name = "foo_dylib",
+        srcs = ["foo.rs"],
+        deps = [":libbar.so"],
+    )
+
+    rust_static_library(
+        name = "foo_static",
+        srcs = ["foo.rs"],
+        deps = [":libbar.so"],
+    )
+
+    # buildifier: disable=native-cc
+    native.cc_binary(
+        name = "libbar.so",
+        srcs = ["bar.cc"],
+        linkshared = True,
+    )
+
+    check_runfiles_test(
+        name = "check_runfiles_lib_test",
+        target_under_test = ":foo_lib",
+    )
+
+    check_runfiles_test(
+        name = "check_runfiles_bin_test",
+        target_under_test = ":foo_bin",
+    )
+
+    check_runfiles_test(
+        name = "check_runfiles_dylib_test",
+        target_under_test = ":foo_dylib",
+    )
+
+    check_runfiles_test(
+        name = "check_runfiles_static_test",
+        target_under_test = ":foo_static",
+    )
+
+def check_runfiles_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _check_runfiles_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":check_runfiles_lib_test",
+            ":check_runfiles_bin_test",
+            ":check_runfiles_dylib_test",
+            ":check_runfiles_static_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/check_runfiles/foo.rs b/third_party/rules_rust/test/unit/check_runfiles/foo.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/check_runfiles/foo.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/check_runfiles/foo_main.rs b/third_party/rules_rust/test/unit/check_runfiles/foo_main.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/check_runfiles/foo_main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/test/unit/clippy/BUILD.bazel b/third_party/rules_rust/test/unit/clippy/BUILD.bazel
new file mode 100644
index 0000000..0220ccb
--- /dev/null
+++ b/third_party/rules_rust/test/unit/clippy/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":clippy_test.bzl", "clippy_test_suite")
+
+clippy_test_suite(
+    name = "clippy_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/clippy/clippy_test.bzl b/third_party/rules_rust/test/unit/clippy/clippy_test.bzl
new file mode 100644
index 0000000..f08cb6c
--- /dev/null
+++ b/third_party/rules_rust/test/unit/clippy/clippy_test.bzl
@@ -0,0 +1,102 @@
+"""Unittest to verify properties of clippy rules"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_clippy_aspect")
+load("//test/unit:common.bzl", "assert_argv_contains", "assert_list_contains_adjacent_elements")
+
+def _find_clippy_action(actions):
+    for action in actions:
+        if action.mnemonic == "Clippy":
+            return action
+    fail("Failed to find Clippy action")
+
+def _clippy_aspect_action_has_flag_impl(ctx, flags):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    clippy_action = _find_clippy_action(target.actions)
+
+    # Ensure each flag is present in the clippy action
+    for flag in flags:
+        assert_argv_contains(
+            env,
+            clippy_action,
+            flag,
+        )
+
+    clippy_checks = target[OutputGroupInfo].clippy_checks.to_list()
+    if len(clippy_checks) != 1:
+        fail("clippy_checks is only expected to contain 1 file")
+
+    # Ensure the arguments to generate the marker file are present in
+    # the clippy action
+    assert_list_contains_adjacent_elements(
+        env,
+        clippy_action.argv,
+        [
+            "--touch-file",
+            clippy_checks[0].path,
+        ],
+    )
+
+    return analysistest.end(env)
+
+def _binary_clippy_aspect_action_has_warnings_flag_test_impl(ctx):
+    return _clippy_aspect_action_has_flag_impl(
+        ctx,
+        ["-Dwarnings"],
+    )
+
+def _library_clippy_aspect_action_has_warnings_flag_test_impl(ctx):
+    return _clippy_aspect_action_has_flag_impl(
+        ctx,
+        ["-Dwarnings"],
+    )
+
+def _test_clippy_aspect_action_has_warnings_flag_test_impl(ctx):
+    return _clippy_aspect_action_has_flag_impl(
+        ctx,
+        [
+            "-Dwarnings",
+            "--test",
+        ],
+    )
+
+def make_clippy_aspect_unittest(impl):
+    return analysistest.make(
+        impl,
+        extra_target_under_test_aspects = [rust_clippy_aspect],
+    )
+
+binary_clippy_aspect_action_has_warnings_flag_test = make_clippy_aspect_unittest(_binary_clippy_aspect_action_has_warnings_flag_test_impl)
+library_clippy_aspect_action_has_warnings_flag_test = make_clippy_aspect_unittest(_library_clippy_aspect_action_has_warnings_flag_test_impl)
+test_clippy_aspect_action_has_warnings_flag_test = make_clippy_aspect_unittest(_test_clippy_aspect_action_has_warnings_flag_test_impl)
+
+def clippy_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+
+    binary_clippy_aspect_action_has_warnings_flag_test(
+        name = "binary_clippy_aspect_action_has_warnings_flag_test",
+        target_under_test = Label("//test/clippy:ok_binary"),
+    )
+    library_clippy_aspect_action_has_warnings_flag_test(
+        name = "library_clippy_aspect_action_has_warnings_flag_test",
+        target_under_test = Label("//test/clippy:ok_library"),
+    )
+    test_clippy_aspect_action_has_warnings_flag_test(
+        name = "test_clippy_aspect_action_has_warnings_flag_test",
+        target_under_test = Label("//test/clippy:ok_test"),
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":binary_clippy_aspect_action_has_warnings_flag_test",
+            ":library_clippy_aspect_action_has_warnings_flag_test",
+            ":test_clippy_aspect_action_has_warnings_flag_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/common.bzl b/third_party/rules_rust/test/unit/common.bzl
new file mode 100644
index 0000000..a0632c0
--- /dev/null
+++ b/third_party/rules_rust/test/unit/common.bzl
@@ -0,0 +1,121 @@
+"""Common test helpers for unit tests."""
+
+load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
+
+def assert_argv_contains_not(env, action, flag):
+    asserts.true(
+        env,
+        flag not in action.argv,
+        "Expected {args} to not contain {flag}".format(args = action.argv, flag = flag),
+    )
+
+def assert_argv_contains(env, action, flag):
+    asserts.true(
+        env,
+        flag in action.argv,
+        "Expected {args} to contain {flag}".format(args = action.argv, flag = flag),
+    )
+
+def assert_argv_contains_prefix_suffix(env, action, prefix, suffix):
+    for found_flag in action.argv:
+        if found_flag.startswith(prefix) and found_flag.endswith(suffix):
+            return
+    unittest.fail(
+        env,
+        "Expected an arg with prefix '{prefix}' and suffix '{suffix}' in {args}".format(
+            prefix = prefix,
+            suffix = suffix,
+            args = action.argv,
+        ),
+    )
+
+def assert_argv_contains_prefix(env, action, prefix):
+    for found_flag in action.argv:
+        if found_flag.startswith(prefix):
+            return
+    unittest.fail(
+        env,
+        "Expected an arg with prefix '{prefix}' in {args}".format(
+            prefix = prefix,
+            args = action.argv,
+        ),
+    )
+
+def assert_argv_contains_prefix_not(env, action, prefix):
+    for found_flag in action.argv:
+        if found_flag.startswith(prefix):
+            unittest.fail(
+                env,
+                "Expected an arg with prefix '{prefix}' to not appear in {args}".format(
+                    prefix = prefix,
+                    args = action.argv,
+                ),
+            )
+
+def assert_action_mnemonic(env, action, mnemonic):
+    if not action.mnemonic == mnemonic:
+        unittest.fail(
+            env,
+            "Expected the action to have the mnemonic '{expected}', but got '{actual}'".format(
+                expected = mnemonic,
+                actual = action.mnemonic,
+            ),
+        )
+
+def _startswith(list, prefix):
+    if len(list) < len(prefix):
+        return False
+    for pair in zip(list[:len(prefix) + 1], prefix):
+        if pair[0] != pair[1]:
+            return False
+    return True
+
+def assert_list_contains_adjacent_elements(env, list_under_test, adjacent_elements):
+    """Assert that list_under_test contains given adjacent flags.
+
+    Args:
+          env: env from analysistest.begin(ctx).
+          list_under_test: list supposed to contain adjacent elements.
+          adjacent_elements: list of elements to be found inside list_under_test.
+    """
+    for idx in range(len(list_under_test)):
+        if list_under_test[idx] == adjacent_elements[0]:
+            if _startswith(list_under_test[idx:], adjacent_elements):
+                return
+
+    unittest.fail(
+        env,
+        "Expected the to find '{expected}' within '{actual}'".format(
+            expected = adjacent_elements,
+            actual = list_under_test,
+        ),
+    )
+
+def assert_list_contains_adjacent_elements_not(env, list_under_test, adjacent_elements):
+    """Assert that list_under_test does not contains given adjacent flags.
+
+    Args:
+          env: env from analysistest.begin(ctx).
+          list_under_test: list supposed not to contain adjacent elements.
+          adjacent_elements: list of elements not to be found inside list_under_test."""
+    for idx in range(len(list_under_test)):
+        if list_under_test[idx] == adjacent_elements[0]:
+            if _startswith(list_under_test[idx:], adjacent_elements):
+                unittest.fail(
+                    env,
+                    "Expected not the to find '{expected}' within '{actual}'".format(
+                        expected = adjacent_elements,
+                        actual = list_under_test,
+                    ),
+                )
+
+def assert_env_value(env, action, key, value):
+    asserts.true(
+        env,
+        action.env[key] == value,
+        "Expected env[{key}] to be equal to '{value}', got '{real_value}'".format(
+            key = key,
+            value = value,
+            real_value = action.env[key],
+        ),
+    )
diff --git a/third_party/rules_rust/test/unit/compile_data/BUILD.bazel b/third_party/rules_rust/test/unit/compile_data/BUILD.bazel
new file mode 100644
index 0000000..8fce69a
--- /dev/null
+++ b/third_party/rules_rust/test/unit/compile_data/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":compile_data_test.bzl", "compile_data_test_suite")
+
+compile_data_test_suite(
+    name = "compile_data_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/compile_data/compile_data.rs b/third_party/rules_rust/test/unit/compile_data/compile_data.rs
new file mode 100644
index 0000000..26f060e
--- /dev/null
+++ b/third_party/rules_rust/test/unit/compile_data/compile_data.rs
@@ -0,0 +1,26 @@
+/// Data loaded from compile data
+pub const COMPILE_DATA: &str = include_str!("compile_data.txt");
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /// A test that is expected to be compiled from a target that does not
+    /// directly populate the `compile_data` attribute
+    #[test]
+    fn test_compile_data_contents() {
+        assert_eq!(COMPILE_DATA.trim_end(), "compile data contents");
+    }
+
+    /// An extra module that tests the `rust_test` rule wrapping the
+    /// `rust_library` is able to provide it's own compile data.
+    #[cfg(test_compile_data)]
+    mod test_compile_data {
+        const TEST_COMPILE_DATA: &str = include_str!("test_compile_data.txt");
+
+        #[test]
+        fn test_compile_data_contents() {
+            assert_eq!(TEST_COMPILE_DATA.trim_end(), "test compile data contents");
+        }
+    }
+}
diff --git a/third_party/rules_rust/test/unit/compile_data/compile_data.txt b/third_party/rules_rust/test/unit/compile_data/compile_data.txt
new file mode 100644
index 0000000..6d8daa7
--- /dev/null
+++ b/third_party/rules_rust/test/unit/compile_data/compile_data.txt
@@ -0,0 +1 @@
+compile data contents
diff --git a/third_party/rules_rust/test/unit/compile_data/compile_data_test.bzl b/third_party/rules_rust/test/unit/compile_data/compile_data_test.bzl
new file mode 100644
index 0000000..43782cd
--- /dev/null
+++ b/third_party/rules_rust/test/unit/compile_data/compile_data_test.bzl
@@ -0,0 +1,99 @@
+"""Unittest to verify compile_data (attribute) propagation"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_common", "rust_library", "rust_test")
+
+def _target_has_compile_data(ctx, expected):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    # Extract compile_data from a target expected to have a `CrateInfo` provider
+    crate_info = target[rust_common.crate_info]
+    compile_data = crate_info.compile_data.to_list()
+
+    # Ensure compile data was correctly propagated to the provider
+    asserts.equals(
+        env,
+        sorted([data.short_path for data in compile_data]),
+        expected,
+    )
+
+    return analysistest.end(env)
+
+def _compile_data_propagates_to_crate_info_test_impl(ctx):
+    return _target_has_compile_data(
+        ctx,
+        ["test/unit/compile_data/compile_data.txt"],
+    )
+
+def _wrapper_rule_propagates_to_crate_info_test_impl(ctx):
+    return _target_has_compile_data(
+        ctx,
+        ["test/unit/compile_data/compile_data.txt"],
+    )
+
+def _wrapper_rule_propagates_and_joins_compile_data_test_impl(ctx):
+    return _target_has_compile_data(
+        ctx,
+        [
+            "test/unit/compile_data/compile_data.txt",
+            "test/unit/compile_data/test_compile_data.txt",
+        ],
+    )
+
+compile_data_propagates_to_crate_info_test = analysistest.make(_compile_data_propagates_to_crate_info_test_impl)
+wrapper_rule_propagates_to_crate_info_test = analysistest.make(_wrapper_rule_propagates_to_crate_info_test_impl)
+wrapper_rule_propagates_and_joins_compile_data_test = analysistest.make(_wrapper_rule_propagates_and_joins_compile_data_test_impl)
+
+def _define_test_targets():
+    rust_library(
+        name = "compile_data",
+        srcs = ["compile_data.rs"],
+        compile_data = ["compile_data.txt"],
+        edition = "2018",
+    )
+
+    rust_test(
+        name = "compile_data_unit_test",
+        crate = ":compile_data",
+    )
+
+    rust_test(
+        name = "test_compile_data_unit_test",
+        compile_data = ["test_compile_data.txt"],
+        crate = ":compile_data",
+        rustc_flags = ["--cfg=test_compile_data"],
+    )
+
+def compile_data_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+
+    _define_test_targets()
+
+    compile_data_propagates_to_crate_info_test(
+        name = "compile_data_propagates_to_crate_info_test",
+        target_under_test = ":compile_data",
+    )
+
+    wrapper_rule_propagates_to_crate_info_test(
+        name = "wrapper_rule_propagates_to_crate_info_test",
+        target_under_test = ":compile_data_unit_test",
+    )
+
+    wrapper_rule_propagates_and_joins_compile_data_test(
+        name = "wrapper_rule_propagates_and_joins_compile_data_test",
+        target_under_test = ":test_compile_data_unit_test",
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":compile_data_propagates_to_crate_info_test",
+            ":wrapper_rule_propagates_to_crate_info_test",
+            ":wrapper_rule_propagates_and_joins_compile_data_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/compile_data/test_compile_data.txt b/third_party/rules_rust/test/unit/compile_data/test_compile_data.txt
new file mode 100644
index 0000000..31ce1d3
--- /dev/null
+++ b/third_party/rules_rust/test/unit/compile_data/test_compile_data.txt
@@ -0,0 +1 @@
+test compile data contents
diff --git a/third_party/rules_rust/test/unit/consistent_crate_name/BUILD.bazel b/third_party/rules_rust/test/unit/consistent_crate_name/BUILD.bazel
new file mode 100644
index 0000000..274e273
--- /dev/null
+++ b/third_party/rules_rust/test/unit/consistent_crate_name/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":consistent_crate_name_test.bzl", "consistent_crate_name_test_suite")
+
+############################ UNIT TESTS #############################
+consistent_crate_name_test_suite(name = "consistent_crate_name_test_suite")
diff --git a/third_party/rules_rust/test/unit/consistent_crate_name/consistent_crate_name_test.bzl b/third_party/rules_rust/test/unit/consistent_crate_name/consistent_crate_name_test.bzl
new file mode 100644
index 0000000..1ea86ad
--- /dev/null
+++ b/third_party/rules_rust/test/unit/consistent_crate_name/consistent_crate_name_test.bzl
@@ -0,0 +1,46 @@
+"""Unittest to verify that we can treat all dependencies as direct dependencies"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//test/unit:common.bzl", "assert_action_mnemonic", "assert_env_value")
+load("//test/unit/consistent_crate_name:with_modified_crate_name.bzl", "with_modified_crate_name")
+
+def _consistent_crate_name_env_test(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    assert_env_value(
+        env,
+        action,
+        "CARGO_CRATE_NAME",
+        "lib_my_custom_crate_suffix",
+    )
+    return analysistest.end(env)
+
+consistent_crate_name_env_test = analysistest.make(_consistent_crate_name_env_test)
+
+def _consistent_crate_name_test():
+    with_modified_crate_name(
+        name = "lib",
+        src = "lib.rs",
+    )
+
+    consistent_crate_name_env_test(
+        name = "consistent_crate_name_env_test",
+        target_under_test = ":lib",
+    )
+
+def consistent_crate_name_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _consistent_crate_name_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":consistent_crate_name_env_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/consistent_crate_name/lib.rs b/third_party/rules_rust/test/unit/consistent_crate_name/lib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/consistent_crate_name/lib.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/consistent_crate_name/with_modified_crate_name.bzl b/third_party/rules_rust/test/unit/consistent_crate_name/with_modified_crate_name.bzl
new file mode 100644
index 0000000..f30d8be
--- /dev/null
+++ b/third_party/rules_rust/test/unit/consistent_crate_name/with_modified_crate_name.bzl
@@ -0,0 +1,75 @@
+"""A custom rule that threats all its dependencies as direct dependencies."""
+
+load("//rust:defs.bzl", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:providers.bzl", "BuildInfo", "CrateInfo", "DepInfo", "DepVariantInfo")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:rustc.bzl", "rustc_compile_action")
+
+def _with_modified_crate_name_impl(ctx):
+    toolchain = ctx.toolchains[Label("//rust:toolchain")]
+
+    crate_root = ctx.attr.src.files.to_list()[0]
+    output_hash = repr(hash(crate_root.path))
+    crate_name = ctx.label.name + "_my_custom_crate_suffix"
+    crate_type = "rlib"
+
+    rust_lib_name = "{prefix}{name}-{lib_hash}{extension}".format(
+        prefix = "lib",
+        name = crate_name,
+        lib_hash = output_hash,
+        extension = ".rlib",
+    )
+
+    deps = [DepVariantInfo(
+        crate_info = dep[CrateInfo] if CrateInfo in dep else None,
+        dep_info = dep[DepInfo] if DepInfo in dep else None,
+        build_info = dep[BuildInfo] if BuildInfo in dep else None,
+        cc_info = dep[CcInfo] if CcInfo in dep else None,
+    ) for dep in ctx.attr.deps]
+
+    rust_lib = ctx.actions.declare_file(rust_lib_name)
+    return rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = crate_type,
+            root = crate_root,
+            srcs = ctx.attr.src.files,
+            deps = depset(deps),
+            proc_macro_deps = depset([]),
+            aliases = {},
+            output = rust_lib,
+            owner = ctx.label,
+            edition = "2018",
+            compile_data = depset([]),
+            rustc_env = {},
+            is_test = False,
+        ),
+        output_hash = output_hash,
+    )
+
+with_modified_crate_name = rule(
+    implementation = _with_modified_crate_name_impl,
+    attrs = {
+        "deps": attr.label_list(),
+        "src": attr.label(allow_single_file = [".rs"]),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_error_format": attr.label(default = "@rules_rust//:error_format"),
+        "_process_wrapper": attr.label(
+            default = Label("@rules_rust//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+    },
+    toolchains = ["@rules_rust//rust:toolchain", "@bazel_tools//tools/cpp:toolchain_type"],
+    incompatible_use_toolchain_transition = True,
+    fragments = ["cpp"],
+)
diff --git a/third_party/rules_rust/test/unit/crate_name/BUILD.bazel b/third_party/rules_rust/test/unit/crate_name/BUILD.bazel
new file mode 100644
index 0000000..b3c9489
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_name/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":crate_name_test.bzl", "crate_name_test_suite")
+
+############################ UNIT TESTS #############################
+crate_name_test_suite(name = "crate_name_test_suite")
diff --git a/third_party/rules_rust/test/unit/crate_name/crate_name_test.bzl b/third_party/rules_rust/test/unit/crate_name/crate_name_test.bzl
new file mode 100644
index 0000000..ccc7a18
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_name/crate_name_test.bzl
@@ -0,0 +1,222 @@
+"""Unit tests for crate names."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
+load("//test/unit:common.bzl", "assert_argv_contains")
+
+def _default_crate_name_library_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    # Note: Hyphens in crate name converted to underscores.
+    assert_argv_contains(env, tut.actions[0], "--crate-name=default_crate_name_library")
+    return analysistest.end(env)
+
+def _custom_crate_name_library_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    assert_argv_contains(env, tut.actions[0], "--crate-name=custom_name")
+    return analysistest.end(env)
+
+def _default_crate_name_binary_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    # Note: Hyphens in crate name converted to underscores.
+    assert_argv_contains(env, tut.actions[0], "--crate-name=default_crate_name_binary")
+    return analysistest.end(env)
+
+def _custom_crate_name_binary_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    assert_argv_contains(env, tut.actions[0], "--crate-name=custom_name")
+    return analysistest.end(env)
+
+def _default_crate_name_test_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    # Note: Hyphens in crate name converted to underscores.
+    assert_argv_contains(env, tut.actions[0], "--crate-name=default_crate_name_test")
+    return analysistest.end(env)
+
+def _custom_crate_name_test_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    assert_argv_contains(env, tut.actions[0], "--crate-name=custom_name")
+    return analysistest.end(env)
+
+def _invalid_default_crate_name_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    asserts.expect_failure(env, "contains invalid character(s): /")
+    return analysistest.end(env)
+
+def _invalid_custom_crate_name_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    asserts.expect_failure(env, "contains invalid character(s): -")
+    return analysistest.end(env)
+
+def _slib_library_name_test_impl(ctx):
+    """Regression test for extra-filename.
+
+    Checks that the extra hash value appended to the library filename only
+    contains one dash. Previously, the hash for `slib` was negative,
+    resulting in an extra dash in the filename (--codegen_extra_filename=--NUM).
+
+    Args:
+      ctx: rule context.
+    """
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    assert_argv_contains(env, tut.actions[0], "--codegen=extra-filename=-2102077805")
+    return analysistest.end(env)
+
+default_crate_name_library_test = analysistest.make(
+    _default_crate_name_library_test_impl,
+)
+custom_crate_name_library_test = analysistest.make(
+    _custom_crate_name_library_test_impl,
+)
+default_crate_name_binary_test = analysistest.make(
+    _default_crate_name_binary_test_impl,
+)
+custom_crate_name_binary_test = analysistest.make(
+    _custom_crate_name_binary_test_impl,
+)
+default_crate_name_test_test = analysistest.make(
+    _default_crate_name_test_test_impl,
+)
+custom_crate_name_test_test = analysistest.make(
+    _custom_crate_name_test_test_impl,
+)
+invalid_default_crate_name_test = analysistest.make(
+    _invalid_default_crate_name_test_impl,
+    expect_failure = True,
+)
+invalid_custom_crate_name_test = analysistest.make(
+    _invalid_custom_crate_name_test_impl,
+    expect_failure = True,
+)
+slib_library_name_test = analysistest.make(
+    _slib_library_name_test_impl,
+)
+
+def _crate_name_test():
+    rust_library(
+        name = "default-crate-name-library",
+        srcs = ["lib.rs"],
+    )
+
+    rust_library(
+        name = "custom-crate-name-library",
+        crate_name = "custom_name",
+        srcs = ["lib.rs"],
+    )
+
+    rust_binary(
+        name = "default-crate-name-binary",
+        srcs = ["main.rs"],
+    )
+
+    rust_binary(
+        name = "custom-crate-name-binary",
+        crate_name = "custom_name",
+        srcs = ["main.rs"],
+    )
+
+    rust_test(
+        name = "default-crate-name-test",
+        srcs = ["main.rs"],
+    )
+
+    rust_test(
+        name = "custom-crate-name-test",
+        crate_name = "custom_name",
+        srcs = ["main.rs"],
+    )
+
+    rust_library(
+        name = "invalid/default-crate-name",
+        srcs = ["lib.rs"],
+        tags = ["manual", "norustfmt"],
+    )
+
+    rust_library(
+        name = "invalid-custom-crate-name",
+        crate_name = "hyphens-not-allowed",
+        srcs = ["lib.rs"],
+        tags = ["manual", "norustfmt"],
+    )
+
+    rust_library(
+        name = "slib",
+        srcs = ["slib.rs"],
+    )
+
+    slib_library_name_test(
+        name = "slib_library_name_test",
+        target_under_test = ":slib",
+    )
+
+    default_crate_name_library_test(
+        name = "default_crate_name_library_test",
+        target_under_test = ":default-crate-name-library",
+    )
+
+    custom_crate_name_library_test(
+        name = "custom_crate_name_library_test",
+        target_under_test = ":custom-crate-name-library",
+    )
+
+    default_crate_name_binary_test(
+        name = "default_crate_name_binary_test",
+        target_under_test = ":default-crate-name-binary",
+    )
+
+    custom_crate_name_binary_test(
+        name = "custom_crate_name_binary_test",
+        target_under_test = ":custom-crate-name-binary",
+    )
+
+    default_crate_name_test_test(
+        name = "default_crate_name_test_test",
+        target_under_test = ":default-crate-name-test",
+    )
+
+    custom_crate_name_test_test(
+        name = "custom_crate_name_test_test",
+        target_under_test = ":custom-crate-name-test",
+    )
+
+    invalid_default_crate_name_test(
+        name = "invalid_default_crate_name_test",
+        target_under_test = ":invalid/default-crate-name",
+    )
+
+    invalid_custom_crate_name_test(
+        name = "invalid_custom_crate_name_test",
+        target_under_test = ":invalid-custom-crate-name",
+    )
+
+def crate_name_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+
+    _crate_name_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":default_crate_name_library_test",
+            ":custom_crate_name_library_test",
+            ":default_crate_name_binary_test",
+            ":custom_crate_name_binary_test",
+            ":default_crate_name_test_test",
+            ":custom_crate_name_test_test",
+            ":invalid_default_crate_name_test",
+            ":invalid_custom_crate_name_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/crate_name/lib.rs b/third_party/rules_rust/test/unit/crate_name/lib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_name/lib.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/crate_name/main.rs b/third_party/rules_rust/test/unit/crate_name/main.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_name/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/test/unit/crate_name/slib.rs b/third_party/rules_rust/test/unit/crate_name/slib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_name/slib.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/crate_variants/BUILD.bazel b/third_party/rules_rust/test/unit/crate_variants/BUILD.bazel
new file mode 100644
index 0000000..44cf760
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_variants/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":crate_variants.bzl", "crate_variants_test_suite")
+
+############################ UNIT TESTS #############################
+crate_variants_test_suite(name = "crate_variants_test_suite")
diff --git a/third_party/rules_rust/test/unit/crate_variants/bar.rs b/third_party/rules_rust/test/unit/crate_variants/bar.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_variants/bar.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/crate_variants/crate_variants.bzl b/third_party/rules_rust/test/unit/crate_variants/crate_variants.bzl
new file mode 100644
index 0000000..2fcd6ef
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_variants/crate_variants.bzl
@@ -0,0 +1,53 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_common", "rust_library")
+
+def _crate_variants_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    transitive_crate_outputs = tut[rust_common.dep_info].transitive_crate_outputs.to_list()
+
+    # Both variants of "foo" occur as dependencies.
+    asserts.equals(env, len(transitive_crate_outputs), 2)
+    return analysistest.end(env)
+
+crate_variants_test = analysistest.make(_crate_variants_test_impl)
+
+def _crate_variants_test():
+    rust_library(
+        name = "foo",
+        srcs = ["foo.rs"],
+    )
+
+    rust_library(
+        name = "foo2",
+        crate_name = "foo",
+        srcs = ["foo.rs"],
+    )
+
+    rust_library(
+        name = "bar",
+        srcs = ["bar.rs"],
+        deps = [":foo", ":foo2"],
+    )
+
+    crate_variants_test(
+        name = "crate_variants_test",
+        target_under_test = ":bar",
+    )
+
+def crate_variants_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _crate_variants_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":crate_variants_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/crate_variants/foo.rs b/third_party/rules_rust/test/unit/crate_variants/foo.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/crate_variants/foo.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/debug_info/BUILD.bazel b/third_party/rules_rust/test/unit/debug_info/BUILD.bazel
new file mode 100644
index 0000000..a577c0a
--- /dev/null
+++ b/third_party/rules_rust/test/unit/debug_info/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":debug_info_analysis_test.bzl", "debug_info_analysis_test_suite")
+
+############################ UNIT TESTS #############################
+debug_info_analysis_test_suite(name = "debug_info_analysis_test_suite")
diff --git a/third_party/rules_rust/test/unit/debug_info/debug_info_analysis_test.bzl b/third_party/rules_rust/test/unit/debug_info/debug_info_analysis_test.bzl
new file mode 100644
index 0000000..9dd5ec1
--- /dev/null
+++ b/third_party/rules_rust/test/unit/debug_info/debug_info_analysis_test.bzl
@@ -0,0 +1,104 @@
+"""Analysis tests for debug info in cdylib and bin targets."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_binary", "rust_shared_library")
+
+def _pdb_file_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    files = target[DefaultInfo].files.to_list()
+    asserts.equals(env, len(files), 1)
+    file = files[0]
+    asserts.equals(env, file.extension, "pdb")
+
+    return analysistest.end(env)
+
+pdb_file_test = analysistest.make(_pdb_file_test_impl)
+
+def _dsym_folder_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    files = target[DefaultInfo].files.to_list()
+    asserts.equals(env, len(files), 1)
+    file = files[0]
+    asserts.equals(env, file.extension, "dSYM")
+
+    return analysistest.end(env)
+
+dsym_folder_test = analysistest.make(_dsym_folder_test_impl)
+
+def debug_info_analysis_test_suite(name):
+    """Analysis tests for debug info in cdylib and bin targets.
+
+    Args:
+        name: the test suite name
+    """
+    rust_shared_library(
+        name = "mylib",
+        srcs = ["lib.rs"],
+    )
+
+    native.filegroup(
+        name = "mylib.pdb",
+        srcs = [":mylib"],
+        output_group = "pdb_file",
+    )
+
+    pdb_file_test(
+        name = "lib_pdb_test",
+        target_under_test = ":mylib.pdb",
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    native.filegroup(
+        name = "mylib.dSYM",
+        srcs = [":mylib"],
+        output_group = "dsym_folder",
+    )
+
+    dsym_folder_test(
+        name = "lib_dsym_test",
+        target_under_test = ":mylib.dSYM",
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+
+    rust_binary(
+        name = "myrustbin",
+        srcs = ["main.rs"],
+    )
+
+    native.filegroup(
+        name = "mybin.pdb",
+        srcs = [":myrustbin"],
+        output_group = "pdb_file",
+    )
+
+    pdb_file_test(
+        name = "bin_pdb_test",
+        target_under_test = ":mybin.pdb",
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    native.filegroup(
+        name = "mybin.dSYM",
+        srcs = [":myrustbin"],
+        output_group = "dsym_folder",
+    )
+
+    dsym_folder_test(
+        name = "bin_dsym_test",
+        target_under_test = ":mybin.dSYM",
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":lib_pdb_test",
+            ":lib_dsym_test",
+            ":bin_pdb_test",
+            ":bin_dsym_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/debug_info/lib.rs b/third_party/rules_rust/test/unit/debug_info/lib.rs
new file mode 100644
index 0000000..1f19b6d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/debug_info/lib.rs
@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn hello() {
+    println!("Hello");
+}
diff --git a/third_party/rules_rust/test/unit/debug_info/main.rs b/third_party/rules_rust/test/unit/debug_info/main.rs
new file mode 100644
index 0000000..6d85883
--- /dev/null
+++ b/third_party/rules_rust/test/unit/debug_info/main.rs
@@ -0,0 +1,3 @@
+pub fn main() {
+    println!("Hello");
+}
diff --git a/third_party/rules_rust/test/unit/exports/BUILD.bazel b/third_party/rules_rust/test/unit/exports/BUILD.bazel
new file mode 100644
index 0000000..863e4d0
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":exports_test.bzl", "exports_test_suite")
+
+exports_test_suite(
+    name = "exports_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/exports/exports_test.bzl b/third_party/rules_rust/test/unit/exports/exports_test.bzl
new file mode 100644
index 0000000..4fbb7d4
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/exports_test.bzl
@@ -0,0 +1,77 @@
+"""Unittest to verify re-exported symbols propagate to downstream crates"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//test/unit:common.bzl", "assert_argv_contains_prefix", "assert_argv_contains_prefix_suffix")
+
+def _exports_test_impl(ctx, dependencies, externs):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    action = target.actions[0]
+    asserts.equals(env, action.mnemonic, "Rustc")
+
+    # Transitive symbols that get re-exported are expected to be located by a `-Ldependency` flag.
+    # The assert below ensures that each dependnecy flag is passed to the Rustc action. For details see
+    # https://doc.rust-lang.org/rustc/command-line-arguments.html#-l-add-a-directory-to-the-library-search-path
+    for dep in dependencies:
+        assert_argv_contains_prefix_suffix(
+            env = env,
+            action = action,
+            prefix = "-Ldependency",
+            suffix = dep,
+        )
+
+    for dep in externs:
+        assert_argv_contains_prefix(
+            env = env,
+            action = action,
+            prefix = "--extern={}=".format(dep),
+        )
+
+    return analysistest.end(env)
+
+def _lib_exports_test_impl(ctx):
+    # This test is only expected to be used with
+    # `//test/unit/exports/lib_c`
+    return _exports_test_impl(
+        ctx = ctx,
+        dependencies = ["lib_a", "lib_b"],
+        externs = ["lib_b"],
+    )
+
+def _test_exports_test_impl(ctx):
+    # This test is only expected to be used with
+    # `//test/unit/exports/lib_c:lib_c_test`
+    return _exports_test_impl(
+        ctx = ctx,
+        dependencies = ["lib_a", "lib_b"],
+        externs = ["lib_b"],
+    )
+
+lib_exports_test = analysistest.make(_lib_exports_test_impl)
+test_exports_test = analysistest.make(_test_exports_test_impl)
+
+def exports_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+
+    lib_exports_test(
+        name = "lib_exports_test",
+        target_under_test = "//test/unit/exports/lib_c",
+    )
+
+    test_exports_test(
+        name = "test_exports_test",
+        target_under_test = "//test/unit/exports/lib_c:lib_c_test",
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":lib_exports_test",
+            ":test_exports_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/exports/lib_a/BUILD.bazel b/third_party/rules_rust/test/unit/exports/lib_a/BUILD.bazel
new file mode 100644
index 0000000..c4842fb
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_a/BUILD.bazel
@@ -0,0 +1,9 @@
+load("//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//test:__subpackages__"])
+
+rust_library(
+    name = "lib_a",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+)
diff --git a/third_party/rules_rust/test/unit/exports/lib_a/src/lib.rs b/third_party/rules_rust/test/unit/exports/lib_a/src/lib.rs
new file mode 100644
index 0000000..88432ec
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_a/src/lib.rs
@@ -0,0 +1,7 @@
+pub fn greeting_from(from: &str) -> String {
+    format!("Hello from {}!", from)
+}
+
+pub fn greeting_a() -> String {
+    greeting_from("lib_a")
+}
diff --git a/third_party/rules_rust/test/unit/exports/lib_b/BUILD.bazel b/third_party/rules_rust/test/unit/exports/lib_b/BUILD.bazel
new file mode 100644
index 0000000..8b70011
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_b/BUILD.bazel
@@ -0,0 +1,10 @@
+load("//rust:defs.bzl", "rust_library")
+
+package(default_visibility = ["//test:__subpackages__"])
+
+rust_library(
+    name = "lib_b",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    deps = ["//test/unit/exports/lib_a"],
+)
diff --git a/third_party/rules_rust/test/unit/exports/lib_b/src/lib.rs b/third_party/rules_rust/test/unit/exports/lib_b/src/lib.rs
new file mode 100644
index 0000000..f54855f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_b/src/lib.rs
@@ -0,0 +1,6 @@
+// The functionality from `lib_a` should be usable within this crate
+pub use lib_a::{greeting_a, greeting_from};
+
+pub fn greeting_b() -> String {
+    greeting_from("lib_b")
+}
diff --git a/third_party/rules_rust/test/unit/exports/lib_c/BUILD.bazel b/third_party/rules_rust/test/unit/exports/lib_c/BUILD.bazel
new file mode 100644
index 0000000..3ea9351
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_c/BUILD.bazel
@@ -0,0 +1,15 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//test:__subpackages__"])
+
+rust_library(
+    name = "lib_c",
+    srcs = ["src/lib.rs"],
+    edition = "2018",
+    deps = ["//test/unit/exports/lib_b"],
+)
+
+rust_test(
+    name = "lib_c_test",
+    crate = ":lib_c",
+)
diff --git a/third_party/rules_rust/test/unit/exports/lib_c/src/lib.rs b/third_party/rules_rust/test/unit/exports/lib_c/src/lib.rs
new file mode 100644
index 0000000..6a47a1f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/exports/lib_c/src/lib.rs
@@ -0,0 +1,20 @@
+// This symbol is an export that `lib_b` exports are re-exports from `lib_a`.
+use lib_b::greeting_from;
+
+pub fn greeting_c() -> String {
+    greeting_from("lib_c")
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use lib_b::{greeting_a, greeting_b};
+
+    #[test]
+    fn test_all_greetings() {
+        assert_eq!(greeting_a(), "Hello from lib_a!".to_owned());
+        assert_eq!(greeting_b(), "Hello from lib_b!".to_owned());
+        assert_eq!(greeting_c(), "Hello from lib_c!".to_owned());
+    }
+}
diff --git a/third_party/rules_rust/test/unit/extra_rustc_flags/BUILD.bazel b/third_party/rules_rust/test/unit/extra_rustc_flags/BUILD.bazel
new file mode 100644
index 0000000..52be64d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/extra_rustc_flags/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":extra_rustc_flags_test.bzl", "extra_rustc_flags_test_suite")
+
+extra_rustc_flags_test_suite(
+    name = "extra_rustc_flags_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/extra_rustc_flags/extra_rustc_flags_test.bzl b/third_party/rules_rust/test/unit/extra_rustc_flags/extra_rustc_flags_test.bzl
new file mode 100644
index 0000000..87eb3b5
--- /dev/null
+++ b/third_party/rules_rust/test/unit/extra_rustc_flags/extra_rustc_flags_test.bzl
@@ -0,0 +1,94 @@
+"""Unittest to verify compile_data (attribute) propagation"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_library")
+load("//test/unit:common.bzl", "assert_argv_contains", "assert_argv_contains_not")
+
+EXTRA_FLAG = "--codegen=linker-plugin-lto"
+
+def target_action_contains_not_flag(env, target):
+    action = target.actions[0]
+    asserts.equals(env, "Rustc", action.mnemonic)
+
+    assert_argv_contains_not(
+        env = env,
+        action = action,
+        flag = EXTRA_FLAG,
+    )
+
+def target_action_contains_flag(env, target):
+    action = target.actions[0]
+    asserts.equals(env, "Rustc", action.mnemonic)
+
+    assert_argv_contains(
+        env = env,
+        action = action,
+        flag = EXTRA_FLAG,
+    )
+
+def _extra_rustc_flags_not_present_test(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+    target_action_contains_not_flag(env, target)
+
+    return analysistest.end(env)
+
+def _extra_rustc_flags_present_test(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+    target_action_contains_flag(env, target)
+
+    # Check the exec configuration target does NOT contain.
+    target = ctx.attr.lib_exec
+    target_action_contains_not_flag(env, target)
+
+    return analysistest.end(env)
+
+extra_rustc_flags_not_present_test = analysistest.make(_extra_rustc_flags_not_present_test)
+extra_rustc_flags_present_test = analysistest.make(
+    _extra_rustc_flags_present_test,
+    attrs = {
+        "lib_exec": attr.label(
+            mandatory = True,
+            cfg = "exec",
+        ),
+    },
+    config_settings = {
+        "@//:extra_rustc_flags": [EXTRA_FLAG],
+    },
+)
+
+def _define_test_targets():
+    rust_library(
+        name = "lib",
+        srcs = ["lib.rs"],
+        edition = "2018",
+    )
+
+def extra_rustc_flags_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+
+    _define_test_targets()
+
+    extra_rustc_flags_not_present_test(
+        name = "extra_rustc_flags_not_present_test",
+        target_under_test = ":lib",
+    )
+
+    extra_rustc_flags_present_test(
+        name = "extra_rustc_flags_present_test",
+        target_under_test = ":lib",
+        lib_exec = ":lib",
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":extra_rustc_flags_not_present_test",
+            ":extra_rustc_flags_present_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/extra_rustc_flags/lib.rs b/third_party/rules_rust/test/unit/extra_rustc_flags/lib.rs
new file mode 100644
index 0000000..a38192a
--- /dev/null
+++ b/third_party/rules_rust/test/unit/extra_rustc_flags/lib.rs
@@ -0,0 +1 @@
+pub fn call() {}
diff --git a/third_party/rules_rust/test/unit/force_all_deps_direct/BUILD.bazel b/third_party/rules_rust/test/unit/force_all_deps_direct/BUILD.bazel
new file mode 100644
index 0000000..12f22c5
--- /dev/null
+++ b/third_party/rules_rust/test/unit/force_all_deps_direct/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":force_all_deps_direct_test.bzl", "force_all_deps_direct_test_suite")
+
+############################ UNIT TESTS #############################
+force_all_deps_direct_test_suite(name = "force_all_deps_direct_test_suite")
diff --git a/third_party/rules_rust/test/unit/force_all_deps_direct/direct.rs b/third_party/rules_rust/test/unit/force_all_deps_direct/direct.rs
new file mode 100644
index 0000000..eae45b3
--- /dev/null
+++ b/third_party/rules_rust/test/unit/force_all_deps_direct/direct.rs
@@ -0,0 +1,5 @@
+use transitive::transitive_fn;
+
+pub fn direct_fn() {
+    transitive_fn();
+}
diff --git a/third_party/rules_rust/test/unit/force_all_deps_direct/force_all_deps_direct_test.bzl b/third_party/rules_rust/test/unit/force_all_deps_direct/force_all_deps_direct_test.bzl
new file mode 100644
index 0000000..6cb5147
--- /dev/null
+++ b/third_party/rules_rust/test/unit/force_all_deps_direct/force_all_deps_direct_test.bzl
@@ -0,0 +1,60 @@
+"""Unittest to verify that we can treat all dependencies as direct dependencies"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_library")
+load("//test/unit:common.bzl", "assert_action_mnemonic", "assert_argv_contains_prefix")
+load("//test/unit/force_all_deps_direct:generator.bzl", "generator")
+
+def _force_all_deps_direct_rustc_flags_test(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[1]
+    assert_action_mnemonic(env, action, "Rustc")
+    assert_argv_contains_prefix(
+        env,
+        action,
+        "--extern=transitive",
+    )
+    return analysistest.end(env)
+
+force_all_deps_direct_test = analysistest.make(_force_all_deps_direct_rustc_flags_test)
+
+def _force_all_deps_direct_test():
+    rust_library(
+        name = "direct",
+        srcs = ["direct.rs"],
+        edition = "2018",
+        deps = [":transitive"],
+    )
+
+    rust_library(
+        name = "transitive",
+        srcs = ["transitive.rs"],
+        edition = "2018",
+    )
+
+    generator(
+        name = "generate",
+        deps = [":direct"],
+        tags = ["noclippy"],
+    )
+
+    force_all_deps_direct_test(
+        name = "force_all_deps_direct_rustc_flags_test",
+        target_under_test = ":generate",
+    )
+
+def force_all_deps_direct_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _force_all_deps_direct_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":force_all_deps_direct_rustc_flags_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/force_all_deps_direct/generator.bzl b/third_party/rules_rust/test/unit/force_all_deps_direct/generator.bzl
new file mode 100644
index 0000000..e8ab445
--- /dev/null
+++ b/third_party/rules_rust/test/unit/force_all_deps_direct/generator.bzl
@@ -0,0 +1,92 @@
+"""A custom rule that threats all its dependencies as direct dependencies."""
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:common.bzl", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:providers.bzl", "BuildInfo", "CrateInfo", "DepInfo", "DepVariantInfo")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:rustc.bzl", "rustc_compile_action")
+
+def _generator_impl(ctx):
+    rs_file = ctx.actions.declare_file(ctx.label.name + "_generated.rs")
+    ctx.actions.run_shell(
+        outputs = [rs_file],
+        command = """cat <<EOF > {}
+use direct::direct_fn;
+use transitive::transitive_fn;
+
+pub fn call_both() {}
+    direct_fn();
+    transitive_fn();
+{}
+EOF
+""".format(rs_file.path, "{", "}"),
+        mnemonic = "WriteRsFile",
+    )
+
+    toolchain = ctx.toolchains[Label("//rust:toolchain")]
+
+    # Determine unique hash for this rlib
+    output_hash = repr(hash(rs_file.path))
+    crate_name = ctx.label.name
+    crate_type = "rlib"
+
+    rust_lib_name = "{prefix}{name}-{lib_hash}{extension}".format(
+        prefix = "lib",
+        name = crate_name,
+        lib_hash = output_hash,
+        extension = ".rlib",
+    )
+
+    deps = [DepVariantInfo(
+        crate_info = dep[CrateInfo] if CrateInfo in dep else None,
+        dep_info = dep[DepInfo] if DepInfo in dep else None,
+        build_info = dep[BuildInfo] if BuildInfo in dep else None,
+        cc_info = dep[CcInfo] if CcInfo in dep else None,
+    ) for dep in ctx.attr.deps]
+
+    rust_lib = ctx.actions.declare_file(rust_lib_name)
+    return rustc_compile_action(
+        ctx = ctx,
+        attr = ctx.attr,
+        toolchain = toolchain,
+        crate_info = rust_common.create_crate_info(
+            name = crate_name,
+            type = crate_type,
+            root = rs_file,
+            srcs = depset([rs_file]),
+            deps = depset(deps),
+            proc_macro_deps = depset([]),
+            aliases = {},
+            output = rust_lib,
+            owner = ctx.label,
+            edition = "2018",
+            compile_data = depset([]),
+            rustc_env = {},
+            is_test = False,
+        ),
+        output_hash = output_hash,
+        force_all_deps_direct = True,
+    )
+
+generator = rule(
+    implementation = _generator_impl,
+    attrs = {
+        "deps": attr.label_list(),
+        "_cc_toolchain": attr.label(
+            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
+        ),
+        "_error_format": attr.label(default = "@rules_rust//:error_format"),
+        "_process_wrapper": attr.label(
+            default = Label("@rules_rust//util/process_wrapper"),
+            executable = True,
+            allow_single_file = True,
+            cfg = "exec",
+        ),
+    },
+    toolchains = ["@rules_rust//rust:toolchain", "@bazel_tools//tools/cpp:toolchain_type"],
+    incompatible_use_toolchain_transition = True,
+    fragments = ["cpp"],
+)
diff --git a/third_party/rules_rust/test/unit/force_all_deps_direct/transitive.rs b/third_party/rules_rust/test/unit/force_all_deps_direct/transitive.rs
new file mode 100644
index 0000000..2ac85df
--- /dev/null
+++ b/third_party/rules_rust/test/unit/force_all_deps_direct/transitive.rs
@@ -0,0 +1 @@
+pub fn transitive_fn() {}
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/BUILD.bazel b/third_party/rules_rust/test/unit/interleaved_cc_info/BUILD.bazel
new file mode 100644
index 0000000..1ba1222
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":interleaved_cc_info_test.bzl", "interleaved_cc_info_test_suite")
+
+############################ UNIT TESTS #############################
+interleaved_cc_info_test_suite(name = "interleaved_cc_info_test_suite")
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/a.rs b/third_party/rules_rust/test/unit/interleaved_cc_info/a.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/a.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/b.cc b/third_party/rules_rust/test/unit/interleaved_cc_info/b.cc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/b.cc
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/c.rs b/third_party/rules_rust/test/unit/interleaved_cc_info/c.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/c.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/d.cc b/third_party/rules_rust/test/unit/interleaved_cc_info/d.cc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/d.cc
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/e.rs b/third_party/rules_rust/test/unit/interleaved_cc_info/e.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/e.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/interleaved_cc_info/interleaved_cc_info_test.bzl b/third_party/rules_rust/test/unit/interleaved_cc_info/interleaved_cc_info_test.bzl
new file mode 100644
index 0000000..6afe604
--- /dev/null
+++ b/third_party/rules_rust/test/unit/interleaved_cc_info/interleaved_cc_info_test.bzl
@@ -0,0 +1,72 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//rust:defs.bzl", "rust_library")
+
+def _interleaving_cc_link_order_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    cc_info = tut[CcInfo]
+    linker_inputs = cc_info.linking_context.linker_inputs.to_list()
+    a = linker_inputs[0]
+    b = linker_inputs[1]
+    c = linker_inputs[2]
+    d = linker_inputs[3]
+    e = linker_inputs[4]
+
+    asserts.equals(env, "a", a.owner.name)
+    asserts.equals(env, "b", b.owner.name)
+    asserts.equals(env, "c", c.owner.name)
+    asserts.equals(env, "d", d.owner.name)
+    asserts.equals(env, "e", e.owner.name)
+
+    return analysistest.end(env)
+
+interleaving_cc_link_order_test = analysistest.make(_interleaving_cc_link_order_test_impl)
+
+def _interleaving_link_order_test():
+    rust_library(
+        name = "a",
+        srcs = ["a.rs"],
+        deps = [":b"],
+    )
+    cc_library(
+        name = "b",
+        srcs = ["b.cc"],
+        deps = [":c"],
+    )
+    rust_library(
+        name = "c",
+        srcs = ["c.rs"],
+        deps = [":d"],
+    )
+    cc_library(
+        name = "d",
+        srcs = ["d.cc"],
+        deps = [":e"],
+    )
+    rust_library(
+        name = "e",
+        srcs = ["e.rs"],
+    )
+
+    interleaving_cc_link_order_test(
+        name = "interleaving_cc_link_order_test",
+        target_under_test = ":a",
+    )
+
+def interleaved_cc_info_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _interleaving_link_order_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":interleaving_cc_link_order_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/linkstamps/BUILD.bazel b/third_party/rules_rust/test/unit/linkstamps/BUILD.bazel
new file mode 100644
index 0000000..88c84b7
--- /dev/null
+++ b/third_party/rules_rust/test/unit/linkstamps/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":linkstamps_test.bzl", "linkstamps_test_suite")
+
+############################ UNIT TESTS #############################
+linkstamps_test_suite(name = "linkstamps_test_suite")
diff --git a/third_party/rules_rust/test/unit/linkstamps/foo.rs b/third_party/rules_rust/test/unit/linkstamps/foo.rs
new file mode 100644
index 0000000..da0f5d9
--- /dev/null
+++ b/third_party/rules_rust/test/unit/linkstamps/foo.rs
@@ -0,0 +1 @@
+pub fn main() {}
diff --git a/third_party/rules_rust/test/unit/linkstamps/linkstamp.cc b/third_party/rules_rust/test/unit/linkstamps/linkstamp.cc
new file mode 100644
index 0000000..5f98c8d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/linkstamps/linkstamp.cc
@@ -0,0 +1 @@
+// linkstamp.cc
diff --git a/third_party/rules_rust/test/unit/linkstamps/linkstamps_test.bzl b/third_party/rules_rust/test/unit/linkstamps/linkstamps_test.bzl
new file mode 100644
index 0000000..d7423f3
--- /dev/null
+++ b/third_party/rules_rust/test/unit/linkstamps/linkstamps_test.bzl
@@ -0,0 +1,156 @@
+"""Unittests for rust linkstamp support."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
+load("//test/unit:common.bzl", "assert_action_mnemonic")
+
+def _is_running_on_linux(ctx):
+    return ctx.target_platform_has_constraint(ctx.attr._linux[platform_common.ConstraintValueInfo])
+
+def _supports_linkstamps_test(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    if not _is_running_on_linux(ctx):
+        # Skipping linkstamps tests on an unsupported (non-Linux) platform
+        return analysistest.end(env)
+
+    linkstamp_action = tut.actions[0]
+    assert_action_mnemonic(env, linkstamp_action, "CppLinkstampCompile")
+    linkstamp_out = linkstamp_action.outputs.to_list()[0]
+    asserts.equals(env, linkstamp_out.basename, "linkstamp.o")
+    tut_out = tut.files.to_list()[0]
+    expected_linkstamp_path = tut_out.dirname + "/_objs/" + tut_out.basename + "/test/unit/linkstamps/linkstamp.o"
+    asserts.equals(
+        env,
+        linkstamp_out.path,
+        expected_linkstamp_path,
+        "Expected linkstamp output '{actual_path}' to match '{expected_path}'".format(
+            actual_path = linkstamp_out.path,
+            expected_path = expected_linkstamp_path,
+        ),
+    )
+
+    rustc_action = tut.actions[1]
+    assert_action_mnemonic(env, rustc_action, "Rustc")
+    rustc_inputs = rustc_action.inputs.to_list()
+    asserts.true(
+        env,
+        linkstamp_out in rustc_inputs,
+        "Expected linkstamp output '{output}' to be among the binary inputs '{inputs}'".format(
+            output = linkstamp_out,
+            inputs = rustc_inputs,
+        ),
+    )
+    return analysistest.end(env)
+
+supports_linkstamps_test = analysistest.make(
+    _supports_linkstamps_test,
+    attrs = {
+        "_linux": attr.label(default = Label("@platforms//os:linux")),
+    },
+)
+
+def _linkstamps_test():
+    # Native linkstamps are only supported by the builtin Linux C++ toolchain. Ideally,
+    # we would be able to inspect the feature_configuration of the target to see if
+    # it has the "linkstamp" feature, but there is no way to get that feature
+    # configuration.
+    cc_library(
+        name = "cc_lib_with_linkstamp",
+        linkstamp = select({
+            "//rust/platform:linux": "linkstamp.cc",
+            "//conditions:default": None,
+        }),
+    )
+
+    rust_binary(
+        name = "some_rust_binary",
+        srcs = ["foo.rs"],
+        deps = [":cc_lib_with_linkstamp"],
+    )
+
+    supports_linkstamps_test(
+        name = "rust_binary_supports_linkstamps_test",
+        target_under_test = ":some_rust_binary",
+    )
+
+    rust_library(
+        name = "some_rust_library_with_linkstamp_transitively",
+        srcs = ["foo.rs"],
+        deps = [":cc_lib_with_linkstamp"],
+    )
+
+    rust_binary(
+        name = "some_rust_binary_with_linkstamp_transitively",
+        srcs = ["foo.rs"],
+        deps = [":some_rust_library_with_linkstamp_transitively"],
+    )
+
+    supports_linkstamps_test(
+        name = "rust_binary_with_linkstamp_transitively",
+        target_under_test = ":some_rust_binary_with_linkstamp_transitively",
+    )
+
+    cc_library(
+        name = "cc_lib_with_linkstamp_transitively",
+        deps = [":cc_lib_with_linkstamp"],
+    )
+
+    rust_binary(
+        name = "some_rust_binary_with_multiple_paths_to_a_linkstamp",
+        srcs = ["foo.rs"],
+        deps = [":cc_lib_with_linkstamp", ":cc_lib_with_linkstamp_transitively"],
+    )
+
+    supports_linkstamps_test(
+        name = "rust_binary_supports_duplicated_linkstamps",
+        target_under_test = ":some_rust_binary_with_multiple_paths_to_a_linkstamp",
+    )
+
+    rust_test(
+        name = "some_rust_test1",
+        srcs = ["foo.rs"],
+        deps = [":cc_lib_with_linkstamp"],
+    )
+
+    supports_linkstamps_test(
+        name = "rust_test_supports_linkstamps_test1",
+        target_under_test = ":some_rust_test1",
+    )
+
+    rust_test(
+        name = "some_rust_test2",
+        srcs = ["foo.rs"],
+        deps = [":cc_lib_with_linkstamp"],
+    )
+
+    supports_linkstamps_test(
+        name = "rust_test_supports_linkstamps_test2",
+        target_under_test = ":some_rust_test2",
+    )
+
+def linkstamps_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+      name: Name of the macro.
+    """
+
+    # Older versions of Bazel do not support Starlark linkstamps.
+    if not hasattr(cc_common, "register_linkstamp_compile_action"):
+        # buildifier: disable=print
+        print("Skipping linkstamps tests since this Bazel version does not support Starlark linkstamps.")
+        return
+
+    _linkstamps_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":rust_binary_supports_linkstamps_test",
+            ":rust_binary_supports_duplicated_linkstamps",
+            ":rust_test_supports_linkstamps_test1",
+            ":rust_test_supports_linkstamps_test2",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/location_expansion/BUILD.bazel b/third_party/rules_rust/test/unit/location_expansion/BUILD.bazel
new file mode 100644
index 0000000..83bf6c6
--- /dev/null
+++ b/third_party/rules_rust/test/unit/location_expansion/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":location_expansion_test.bzl", "location_expansion_test_suite")
+
+############################ UNIT TESTS #############################
+location_expansion_test_suite(name = "location_expansion_test_suite")
diff --git a/third_party/rules_rust/test/unit/location_expansion/location_expansion_test.bzl b/third_party/rules_rust/test/unit/location_expansion/location_expansion_test.bzl
new file mode 100644
index 0000000..caec57c
--- /dev/null
+++ b/third_party/rules_rust/test/unit/location_expansion/location_expansion_test.bzl
@@ -0,0 +1,53 @@
+"""Unittest to verify location expansion in rustc flags"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_library")
+load("//test/unit:common.bzl", "assert_action_mnemonic", "assert_argv_contains")
+
+def _location_expansion_rustc_flags_test(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    assert_argv_contains(env, action, "test/unit/location_expansion/mylibrary.rs")
+    expected = "@${pwd}/" + ctx.bin_dir.path + "/test/unit/location_expansion/generated_flag.data"
+    assert_argv_contains(env, action, expected)
+    return analysistest.end(env)
+
+location_expansion_rustc_flags_test = analysistest.make(_location_expansion_rustc_flags_test)
+
+def _location_expansion_test():
+    native.genrule(
+        name = "flag_generator",
+        outs = ["generated_flag.data"],
+        cmd = "echo --cfg=test_flag > $@",
+    )
+
+    rust_library(
+        name = "mylibrary",
+        srcs = ["mylibrary.rs"],
+        rustc_flags = [
+            "@$(location :flag_generator)",
+        ],
+        compile_data = [":flag_generator"],
+    )
+
+    location_expansion_rustc_flags_test(
+        name = "location_expansion_rustc_flags_test",
+        target_under_test = ":mylibrary",
+    )
+
+def location_expansion_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _location_expansion_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":location_expansion_rustc_flags_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/location_expansion/mylibrary.rs b/third_party/rules_rust/test/unit/location_expansion/mylibrary.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/location_expansion/mylibrary.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/native_deps/BUILD.bazel b/third_party/rules_rust/test/unit/native_deps/BUILD.bazel
new file mode 100644
index 0000000..cfb6557
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/BUILD.bazel
@@ -0,0 +1,7 @@
+load(":native_action_inputs_test.bzl", "native_action_inputs_test_suite")
+load(":native_deps_test.bzl", "native_deps_test_suite")
+
+############################ UNIT TESTS #############################
+native_deps_test_suite(name = "native_deps_test_suite")
+
+native_action_inputs_test_suite(name = "native_action_inputs_test_suite")
diff --git a/third_party/rules_rust/test/unit/native_deps/alwayslink.cc b/third_party/rules_rust/test/unit/native_deps/alwayslink.cc
new file mode 100644
index 0000000..bd98ce0
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/alwayslink.cc
@@ -0,0 +1 @@
+extern "C" int alwayslink() { return 42; }
diff --git a/third_party/rules_rust/test/unit/native_deps/bar.cc b/third_party/rules_rust/test/unit/native_deps/bar.cc
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/bar.cc
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/native_deps/bin_using_native_dep.rs b/third_party/rules_rust/test/unit/native_deps/bin_using_native_dep.rs
new file mode 100644
index 0000000..b128c4f
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/bin_using_native_dep.rs
@@ -0,0 +1,6 @@
+extern "C" {
+    fn native_dep() -> isize;
+}
+fn main() {
+    println!("{}", unsafe { native_dep() })
+}
diff --git a/third_party/rules_rust/test/unit/native_deps/dynamic.lds b/third_party/rules_rust/test/unit/native_deps/dynamic.lds
new file mode 100644
index 0000000..022df8c
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/dynamic.lds
@@ -0,0 +1,2 @@
+{
+};
diff --git a/third_party/rules_rust/test/unit/native_deps/foo.rs b/third_party/rules_rust/test/unit/native_deps/foo.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/foo.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/native_deps/foo_main.rs b/third_party/rules_rust/test/unit/native_deps/foo_main.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/foo_main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/test/unit/native_deps/lib_using_native_dep.rs b/third_party/rules_rust/test/unit/native_deps/lib_using_native_dep.rs
new file mode 100644
index 0000000..0e8ddae
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/lib_using_native_dep.rs
@@ -0,0 +1,6 @@
+extern "C" {
+    fn native_dep() -> isize;
+}
+pub fn use_native_dep() {
+    println!("{}", unsafe { native_dep() })
+}
diff --git a/third_party/rules_rust/test/unit/native_deps/native_action_inputs_test.bzl b/third_party/rules_rust/test/unit/native_deps/native_action_inputs_test.bzl
new file mode 100644
index 0000000..2363e1e
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/native_action_inputs_test.bzl
@@ -0,0 +1,155 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load(
+    "//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_shared_library",
+    "rust_static_library",
+)
+load("//test/unit:common.bzl", "assert_action_mnemonic")
+
+def _native_action_inputs_present_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    inputs = action.inputs.to_list()
+    lib_name = _native_dep_lib_name(ctx)
+
+    asserts.true(
+        env,
+        _has_action_input(lib_name, inputs),
+        "Expected to contain {lib_name} as action input, got {inputs}".format(
+            lib_name = lib_name,
+            inputs = inputs,
+        ),
+    )
+
+    return analysistest.end(env)
+
+def _native_action_inputs_not_present_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    inputs = action.inputs.to_list()
+    lib_name = _native_dep_lib_name(ctx)
+
+    asserts.false(
+        env,
+        _has_action_input(lib_name, inputs),
+        "Expected not to contain {lib_name}".format(lib_name = lib_name),
+    )
+
+    return analysistest.end(env)
+
+def _native_dep_lib_name(ctx):
+    if ctx.target_platform_has_constraint(
+        ctx.attr._windows_constraint[platform_common.ConstraintValueInfo],
+    ):
+        return "bar.lib"
+    else:
+        return "libbar.a"
+
+def _has_action_input(name, inputs):
+    for file in inputs:
+        if file.basename == name:
+            return True
+    return False
+
+native_action_inputs_present_test = analysistest.make(
+    _native_action_inputs_present_test_impl,
+    attrs = {
+        "_windows_constraint": attr.label(default = Label("@platforms//os:windows")),
+    },
+)
+native_action_inputs_not_present_test = analysistest.make(
+    _native_action_inputs_not_present_test_impl,
+    attrs = {
+        "_windows_constraint": attr.label(default = Label("@platforms//os:windows")),
+    },
+)
+
+def _native_action_inputs_test():
+    rust_library(
+        name = "foo_lib",
+        srcs = ["foo.rs"],
+        deps = [":bar"],
+    )
+
+    rust_binary(
+        name = "foo_bin",
+        srcs = ["foo_main.rs"],
+        deps = [":bar"],
+    )
+
+    rust_shared_library(
+        name = "foo_dylib",
+        srcs = ["foo.rs"],
+        deps = [":bar"],
+    )
+
+    rust_static_library(
+        name = "foo_static",
+        srcs = ["foo.rs"],
+        deps = [":bar"],
+    )
+
+    rust_proc_macro(
+        name = "foo_proc_macro",
+        srcs = ["foo.rs"],
+        deps = [":bar"],
+    )
+
+    # buildifier: disable=native-cc
+    native.cc_library(
+        name = "bar",
+        srcs = ["bar.cc"],
+    )
+
+    native_action_inputs_not_present_test(
+        name = "native_action_inputs_lib_test",
+        target_under_test = ":foo_lib",
+    )
+
+    native_action_inputs_present_test(
+        name = "native_action_inputs_bin_test",
+        target_under_test = ":foo_bin",
+    )
+
+    native_action_inputs_present_test(
+        name = "native_action_inputs_dylib_test",
+        target_under_test = ":foo_dylib",
+    )
+
+    native_action_inputs_present_test(
+        name = "native_action_inputs_static_test",
+        target_under_test = ":foo_static",
+    )
+
+    native_action_inputs_present_test(
+        name = "native_action_inputs_proc_macro_test",
+        target_under_test = ":foo_proc_macro",
+    )
+
+def native_action_inputs_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _native_action_inputs_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":native_action_inputs_lib_test",
+            ":native_action_inputs_bin_test",
+            ":native_action_inputs_dylib_test",
+            ":native_action_inputs_static_test",
+            ":native_action_inputs_proc_macro_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/native_deps/native_dep.cc b/third_party/rules_rust/test/unit/native_deps/native_dep.cc
new file mode 100644
index 0000000..9127b43
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/native_dep.cc
@@ -0,0 +1,3 @@
+int native_global = 42;
+
+extern "C" int native_dep() { return native_global; }
\ No newline at end of file
diff --git a/third_party/rules_rust/test/unit/native_deps/native_deps_test.bzl b/third_party/rules_rust/test/unit/native_deps/native_deps_test.bzl
new file mode 100644
index 0000000..5a91881
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/native_deps_test.bzl
@@ -0,0 +1,366 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_proc_macro", "rust_shared_library", "rust_static_library")
+load(
+    "//test/unit:common.bzl",
+    "assert_argv_contains",
+    "assert_argv_contains_not",
+    "assert_argv_contains_prefix",
+    "assert_argv_contains_prefix_not",
+    "assert_argv_contains_prefix_suffix",
+    "assert_list_contains_adjacent_elements",
+)
+
+def _rlib_has_no_native_libs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_argv_contains(env, action, "--crate-type=rlib")
+    assert_argv_contains_not(env, action, "-lstatic=native_dep")
+    assert_argv_contains_not(env, action, "-ldylib=native_dep")
+    assert_argv_contains_prefix_not(env, action, "--codegen=linker=")
+    return analysistest.end(env)
+
+def _cdylib_has_native_libs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
+    assert_argv_contains(env, action, "--crate-type=cdylib")
+    assert_argv_contains(env, action, "-lstatic=native_dep")
+    assert_argv_contains_prefix(env, action, "--codegen=linker=")
+    return analysistest.end(env)
+
+def _staticlib_has_native_libs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
+    assert_argv_contains(env, action, "--crate-type=staticlib")
+    assert_argv_contains(env, action, "-lstatic=native_dep")
+    assert_argv_contains_prefix(env, action, "--codegen=linker=")
+    return analysistest.end(env)
+
+def _proc_macro_has_native_libs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    asserts.equals(env, 1, len(tut.actions))
+    action = tut.actions[0]
+    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
+    assert_argv_contains(env, action, "--crate-type=proc-macro")
+    assert_argv_contains(env, action, "-lstatic=native_dep")
+    assert_argv_contains_prefix(env, action, "--codegen=linker=")
+    return analysistest.end(env)
+
+def _bin_has_native_libs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
+    assert_argv_contains(env, action, "-lstatic=native_dep")
+    assert_argv_contains_prefix(env, action, "--codegen=linker=")
+    return analysistest.end(env)
+
+def _extract_linker_args(argv):
+    return [a for a in argv if (
+        a.startswith("link-arg=") or
+        a.startswith("link-args=") or
+        a.startswith("-l") or
+        a.endswith(".lo") or
+        a.endswith(".o")
+    )]
+
+def _bin_has_native_dep_and_alwayslink_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+
+    compilation_mode = ctx.var["COMPILATION_MODE"]
+    if ctx.target_platform_has_constraint(ctx.attr._macos_constraint[platform_common.ConstraintValueInfo]):
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=-Wl,-force_load,bazel-out/darwin-{}/bin/test/unit/native_deps/libalwayslink.lo".format(compilation_mode),
+        ]
+    elif ctx.target_platform_has_constraint(ctx.attr._windows_constraint[platform_common.ConstraintValueInfo]):
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=/WHOLEARCHIVE:bazel-out/x64_windows-{}/bin/test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode),
+        ]
+    else:
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=-Wl,--whole-archive",
+            "link-arg=bazel-out/k8-{}/bin/test/unit/native_deps/libalwayslink.lo".format(compilation_mode),
+            "link-arg=-Wl,--no-whole-archive",
+        ]
+    individual_link_args = [
+        arg
+        for arg in _extract_linker_args(action.argv)
+        if arg.startswith("link-arg=") or arg.startswith("-lstatic=")
+    ]
+    asserts.equals(env, want, individual_link_args)
+    return analysistest.end(env)
+
+def _cdylib_has_native_dep_and_alwayslink_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+
+    # skipping first link-arg since it contains unrelated linker flags
+    linker_args = _extract_linker_args(action.argv)[1:]
+
+    compilation_mode = ctx.var["COMPILATION_MODE"]
+    pic_suffix = ".pic" if compilation_mode == "opt" else ""
+    if ctx.target_platform_has_constraint(ctx.attr._macos_constraint[platform_common.ConstraintValueInfo]):
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=-Wl,-force_load,bazel-out/darwin-{}/bin/test/unit/native_deps/libalwayslink{}.lo".format(compilation_mode, pic_suffix),
+        ]
+    elif ctx.target_platform_has_constraint(ctx.attr._windows_constraint[platform_common.ConstraintValueInfo]):
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=/WHOLEARCHIVE:bazel-out/x64_windows-{}/bin/test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode),
+        ]
+    else:
+        want = [
+            "-lstatic=native_dep",
+            "link-arg=-Wl,--whole-archive",
+            "link-arg=bazel-out/k8-{}/bin/test/unit/native_deps/libalwayslink{}.lo".format(compilation_mode, pic_suffix),
+            "link-arg=-Wl,--no-whole-archive",
+        ]
+    asserts.equals(env, want, linker_args)
+    return analysistest.end(env)
+
+rlib_has_no_native_libs_test = analysistest.make(_rlib_has_no_native_libs_test_impl)
+staticlib_has_native_libs_test = analysistest.make(_staticlib_has_native_libs_test_impl)
+cdylib_has_native_libs_test = analysistest.make(_cdylib_has_native_libs_test_impl)
+proc_macro_has_native_libs_test = analysistest.make(_proc_macro_has_native_libs_test_impl)
+bin_has_native_libs_test = analysistest.make(_bin_has_native_libs_test_impl)
+bin_has_native_dep_and_alwayslink_test = analysistest.make(_bin_has_native_dep_and_alwayslink_test_impl, attrs = {
+    "_macos_constraint": attr.label(default = Label("@platforms//os:macos")),
+    "_windows_constraint": attr.label(default = Label("@platforms//os:windows")),
+})
+cdylib_has_native_dep_and_alwayslink_test = analysistest.make(_cdylib_has_native_dep_and_alwayslink_test_impl, attrs = {
+    "_macos_constraint": attr.label(default = Label("@platforms//os:macos")),
+    "_windows_constraint": attr.label(default = Label("@platforms//os:windows")),
+})
+
+def _native_dep_test():
+    rust_library(
+        name = "rlib_has_no_native_dep",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = [":native_dep"],
+    )
+
+    rust_static_library(
+        name = "staticlib_has_native_dep",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = [":native_dep"],
+    )
+
+    rust_shared_library(
+        name = "cdylib_has_native_dep",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = [":native_dep"],
+    )
+
+    rust_proc_macro(
+        name = "proc_macro_has_native_dep",
+        srcs = ["proc_macro_using_native_dep.rs"],
+        deps = [":native_dep"],
+        edition = "2018",
+    )
+
+    rust_binary(
+        name = "bin_has_native_dep",
+        srcs = ["bin_using_native_dep.rs"],
+        deps = [":native_dep"],
+    )
+
+    rust_binary(
+        name = "bin_has_native_dep_and_alwayslink",
+        srcs = ["bin_using_native_dep.rs"],
+        deps = [":native_dep", ":alwayslink"],
+    )
+
+    cc_library(
+        name = "native_dep",
+        srcs = ["native_dep.cc"],
+        visibility = ["//test/unit:__subpackages__"],
+    )
+
+    cc_library(
+        name = "alwayslink",
+        srcs = ["alwayslink.cc"],
+        alwayslink = 1,
+    )
+
+    rust_shared_library(
+        name = "cdylib_has_native_dep_and_alwayslink",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = [":native_dep", ":alwayslink"],
+    )
+
+    rlib_has_no_native_libs_test(
+        name = "rlib_has_no_native_libs_test",
+        target_under_test = ":rlib_has_no_native_dep",
+    )
+    staticlib_has_native_libs_test(
+        name = "staticlib_has_native_libs_test",
+        target_under_test = ":staticlib_has_native_dep",
+    )
+    cdylib_has_native_libs_test(
+        name = "cdylib_has_native_libs_test",
+        target_under_test = ":cdylib_has_native_dep",
+    )
+    proc_macro_has_native_libs_test(
+        name = "proc_macro_has_native_libs_test",
+        target_under_test = ":proc_macro_has_native_dep",
+    )
+    bin_has_native_libs_test(
+        name = "bin_has_native_libs_test",
+        target_under_test = ":bin_has_native_dep",
+    )
+    bin_has_native_dep_and_alwayslink_test(
+        name = "bin_has_native_dep_and_alwayslink_test",
+        target_under_test = ":bin_has_native_dep_and_alwayslink",
+    )
+    cdylib_has_native_dep_and_alwayslink_test(
+        name = "cdylib_has_native_dep_and_alwayslink_test",
+        target_under_test = ":cdylib_has_native_dep_and_alwayslink",
+    )
+
+def _linkopts_propagate_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+
+    # Ensure linkopts from direct (-Llinkoptdep1) and transitive
+    # (-Llinkoptdep2) dependencies are propagated.
+    # Consistently with cc rules, dependency linkopts take precedence over
+    # dependent linkopts (i.e. dependency linkopts appear later in the command
+    # line).
+    linkopt_args = [
+        arg
+        for arg in _extract_linker_args(action.argv)
+        if arg.startswith("link-args")
+    ][0].split(" ")
+    assert_list_contains_adjacent_elements(
+        env,
+        linkopt_args,
+        ["-Llinkoptdep1", "-Llinkoptdep2"],
+    )
+    return analysistest.end(env)
+
+linkopts_propagate_test = analysistest.make(_linkopts_propagate_test_impl)
+
+def _linkopts_test():
+    rust_binary(
+        name = "linkopts_rust_bin",
+        srcs = ["bin_using_native_dep.rs"],
+        deps = [":linkopts_native_dep_a"],
+    )
+
+    cc_library(
+        name = "linkopts_native_dep_a",
+        srcs = ["native_dep.cc"],
+        linkopts = ["-Llinkoptdep1"],
+        deps = [":linkopts_native_dep_b"],
+    )
+
+    cc_library(
+        name = "linkopts_native_dep_b",
+        linkopts = ["-Llinkoptdep2"],
+    )
+
+    linkopts_propagate_test(
+        name = "native_linkopts_propagate_test",
+        target_under_test = ":linkopts_rust_bin",
+    )
+
+def _check_additional_deps_test_impl(ctx, expect_additional_deps):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    additional_inputs = [inp.basename for inp in action.inputs.to_list()]
+    asserts.equals(env, "dynamic.lds" in additional_inputs, expect_additional_deps)
+    return analysistest.end(env)
+
+def _has_additional_deps_test_impl(ctx):
+    return _check_additional_deps_test_impl(ctx, expect_additional_deps = True)
+
+def _has_no_additional_deps_test_impl(ctx):
+    return _check_additional_deps_test_impl(ctx, expect_additional_deps = False)
+
+has_additional_deps_test = analysistest.make(_has_additional_deps_test_impl)
+has_no_additional_deps_test = analysistest.make(_has_no_additional_deps_test_impl)
+
+def _additional_deps_test():
+    rust_binary(
+        name = "bin_additional_deps",
+        srcs = ["bin_using_native_dep.rs"],
+        deps = [":additional_deps_cc"],
+    )
+
+    rust_shared_library(
+        name = "cdylib_additional_deps",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = [":additional_deps_cc"],
+    )
+
+    rust_library(
+        name = "lib_additional_deps",
+        srcs = ["lib_using_native_dep.rs"],
+        deps = ["additional_deps_cc"],
+    )
+
+    cc_library(
+        name = "additional_deps_cc",
+        srcs = ["native_dep.cc"],
+        linkopts = ["-L$(execpath :dynamic.lds)"],
+        deps = [":dynamic.lds"],
+    )
+
+    has_additional_deps_test(
+        name = "bin_has_additional_deps_test",
+        target_under_test = ":bin_additional_deps",
+    )
+
+    has_additional_deps_test(
+        name = "cdylib_has_additional_deps_test",
+        target_under_test = ":cdylib_additional_deps",
+    )
+
+    has_no_additional_deps_test(
+        name = "lib_has_no_additional_deps_test",
+        target_under_test = ":lib_additional_deps",
+    )
+
+def native_deps_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _native_dep_test()
+    _linkopts_test()
+    _additional_deps_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":bin_has_additional_deps_test",
+            ":bin_has_native_dep_and_alwayslink_test",
+            ":bin_has_native_libs_test",
+            ":cdylib_has_additional_deps_test",
+            ":cdylib_has_native_dep_and_alwayslink_test",
+            ":cdylib_has_native_libs_test",
+            ":lib_has_no_additional_deps_test",
+            ":native_linkopts_propagate_test",
+            ":proc_macro_has_native_libs_test",
+            ":rlib_has_no_native_libs_test",
+            ":staticlib_has_native_libs_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/native_deps/proc_macro_using_native_dep.rs b/third_party/rules_rust/test/unit/native_deps/proc_macro_using_native_dep.rs
new file mode 100644
index 0000000..6dcfc22
--- /dev/null
+++ b/third_party/rules_rust/test/unit/native_deps/proc_macro_using_native_dep.rs
@@ -0,0 +1,10 @@
+use proc_macro::TokenStream;
+
+extern "C" {
+    fn native_dep() -> isize;
+}
+#[proc_macro_derive(UsingNativeDep)]
+pub fn use_native_dep(_input: TokenStream) -> TokenStream {
+    println!("{}", unsafe { native_dep() });
+    panic!("done")
+}
diff --git a/third_party/rules_rust/test/unit/proc_macro/BUILD.bazel b/third_party/rules_rust/test/unit/proc_macro/BUILD.bazel
new file mode 100644
index 0000000..e2d56c1
--- /dev/null
+++ b/third_party/rules_rust/test/unit/proc_macro/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":proc_macro_test.bzl", "proc_macro_test_suite")
+
+proc_macro_test_suite(
+    name = "proc_macro_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/proc_macro/proc_macro_2015.rs b/third_party/rules_rust/test/unit/proc_macro/proc_macro_2015.rs
new file mode 100644
index 0000000..53935e4
--- /dev/null
+++ b/third_party/rules_rust/test/unit/proc_macro/proc_macro_2015.rs
@@ -0,0 +1,7 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn make_answer(_item: TokenStream) -> TokenStream {
+    "fn answer() -> u32 { 42 }".parse().unwrap()
+}
diff --git a/third_party/rules_rust/test/unit/proc_macro/proc_macro_2018.rs b/third_party/rules_rust/test/unit/proc_macro/proc_macro_2018.rs
new file mode 100644
index 0000000..9005e0d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/proc_macro/proc_macro_2018.rs
@@ -0,0 +1,9 @@
+// This differs from the edition 2015 version because it does not have an `extern proc_macro`
+// statement, which became optional in edition 2018.
+
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn make_answer(_item: TokenStream) -> TokenStream {
+    "fn answer() -> u32 { 42 }".parse().unwrap()
+}
diff --git a/third_party/rules_rust/test/unit/proc_macro/proc_macro_test.bzl b/third_party/rules_rust/test/unit/proc_macro/proc_macro_test.bzl
new file mode 100644
index 0000000..04a20cc
--- /dev/null
+++ b/third_party/rules_rust/test/unit/proc_macro/proc_macro_test.bzl
@@ -0,0 +1,110 @@
+"""Unittest to verify proc-macro targets"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_proc_macro", "rust_test")
+load(
+    "//test/unit:common.bzl",
+    "assert_action_mnemonic",
+    "assert_argv_contains",
+    "assert_list_contains_adjacent_elements",
+    "assert_list_contains_adjacent_elements_not",
+)
+
+def _proc_macro_test_targets(edition):
+    """Define a set of `rust_proc_macro` targets for testing
+
+    Args:
+        edition (str): The rust edition to use for the new targets
+    """
+    rust_proc_macro(
+        name = "proc_macro_{}".format(edition),
+        srcs = [
+            "proc_macro_{}.rs".format(edition),
+        ],
+        edition = edition,
+        visibility = ["//test:__subpackages__"],
+    )
+
+    rust_test(
+        name = "wrapper_rule_for_macro_{}".format(edition),
+        crate = ":proc_macro_{}".format(edition),
+        edition = edition,
+    )
+
+def _unit_test_impl(ctx, edition, is_wrapper):
+    env = analysistest.begin(ctx)
+    actions = analysistest.target_under_test(env).actions
+    action = actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+
+    if edition == "2015":
+        # Edition 2015 does not use `--extern proc_macro` instead this
+        # must be explicitly set in Rust code.
+        assert_list_contains_adjacent_elements_not(env, action.argv, ["--extern", "proc_macro"])
+    elif edition == "2018":
+        # `--extern proc_macro` is required to resolve build proc-macro
+        assert_list_contains_adjacent_elements(env, action.argv, ["--extern", "proc_macro"])
+        if not is_wrapper:
+            assert_argv_contains(env, action, "--edition=2018")
+    else:
+        fail("Unexpected edition")
+
+    return analysistest.end(env)
+
+def _extern_flag_not_passed_when_compiling_macro_2015_impl(ctx):
+    return _unit_test_impl(ctx, "2015", False)
+
+def _extern_flag_passed_when_compiling_macro_2018_impl(ctx):
+    return _unit_test_impl(ctx, "2018", False)
+
+def _extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_impl(ctx):
+    return _unit_test_impl(ctx, "2015", True)
+
+def _extern_flag_passed_when_compiling_macro_wrapper_rule_2018_impl(ctx):
+    return _unit_test_impl(ctx, "2018", True)
+
+extern_flag_not_passed_when_compiling_macro_2015_test = analysistest.make(_extern_flag_not_passed_when_compiling_macro_2015_impl)
+extern_flag_passed_when_compiling_macro_2018_test = analysistest.make(_extern_flag_passed_when_compiling_macro_2018_impl)
+extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_test = analysistest.make(_extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_impl)
+extern_flag_passed_when_compiling_macro_wrapper_rule_2018_test = analysistest.make(_extern_flag_passed_when_compiling_macro_wrapper_rule_2018_impl)
+
+def _proc_macro_test():
+    """Generate targets and tests"""
+
+    _proc_macro_test_targets("2015")
+    _proc_macro_test_targets("2018")
+
+    extern_flag_not_passed_when_compiling_macro_2015_test(
+        name = "extern_flag_not_passed_when_compiling_macro_2015",
+        target_under_test = ":proc_macro_2015",
+    )
+    extern_flag_passed_when_compiling_macro_2018_test(
+        name = "extern_flag_passed_when_compiling_macro_2018",
+        target_under_test = ":proc_macro_2018",
+    )
+    extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015_test(
+        name = "extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015",
+        target_under_test = ":wrapper_rule_for_macro_2015",
+    )
+    extern_flag_passed_when_compiling_macro_wrapper_rule_2018_test(
+        name = "extern_flag_passed_when_compiling_macro_wrapper_rule_2018",
+        target_under_test = ":wrapper_rule_for_macro_2018",
+    )
+
+def proc_macro_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _proc_macro_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":extern_flag_not_passed_when_compiling_macro_2015",
+            ":extern_flag_passed_when_compiling_macro_2018",
+            ":extern_flag_not_passed_when_compiling_macro_wrapper_rule_2015",
+            ":extern_flag_passed_when_compiling_macro_wrapper_rule_2018",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/repository_utils/BUILD.bazel b/third_party/rules_rust/test/unit/repository_utils/BUILD.bazel
new file mode 100644
index 0000000..cbdf671
--- /dev/null
+++ b/third_party/rules_rust/test/unit/repository_utils/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":repository_utils_test.bzl", "repository_utils_test_suite")
+
+############################ UNIT TESTS #############################
+repository_utils_test_suite(name = "repository_utils_test_suite")
diff --git a/third_party/rules_rust/test/unit/repository_utils/repository_utils_test.bzl b/third_party/rules_rust/test/unit/repository_utils/repository_utils_test.bzl
new file mode 100644
index 0000000..10b0f52
--- /dev/null
+++ b/third_party/rules_rust/test/unit/repository_utils/repository_utils_test.bzl
@@ -0,0 +1,90 @@
+"""Unit tests for repository_utils.bzl."""
+
+load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:repository_utils.bzl", "produce_tool_path", "produce_tool_suburl")
+
+def _produce_tool_suburl_test_impl(ctx):
+    env = unittest.begin(ctx)
+    asserts.equals(
+        env,
+        "2020-05-22/rust-std-nightly-x86_64-unknown-linux-gnu",
+        produce_tool_suburl(
+            iso_date = "2020-05-22",
+            tool_name = "rust-std",
+            version = "nightly",
+            target_triple = "x86_64-unknown-linux-gnu",
+        ),
+    )
+    asserts.equals(
+        env,
+        "rust-std-nightly-x86_64-unknown-linux-gnu",
+        produce_tool_suburl(
+            tool_name = "rust-std",
+            version = "nightly",
+            target_triple = "x86_64-unknown-linux-gnu",
+        ),
+    )
+    asserts.equals(
+        env,
+        "2020-05-22/rust-src-nightly",
+        produce_tool_suburl(
+            iso_date = "2020-05-22",
+            tool_name = "rust-src",
+            version = "nightly",
+            target_triple = None,
+        ),
+    )
+    asserts.equals(
+        env,
+        "rust-src-nightly",
+        produce_tool_suburl(
+            tool_name = "rust-src",
+            version = "nightly",
+            target_triple = None,
+        ),
+    )
+    asserts.equals(
+        env,
+        "rust-src-1.54.0",
+        produce_tool_suburl(
+            iso_date = "2021-08-15",
+            tool_name = "rust-src",
+            version = "1.54.0",
+            target_triple = None,
+        ),
+    )
+    return unittest.end(env)
+
+def _produce_tool_path_test_impl(ctx):
+    env = unittest.begin(ctx)
+    asserts.equals(
+        env,
+        "rust-std-nightly-x86_64-unknown-linux-gnu",
+        produce_tool_path(
+            tool_name = "rust-std",
+            version = "nightly",
+            target_triple = "x86_64-unknown-linux-gnu",
+        ),
+    )
+    asserts.equals(
+        env,
+        "rust-src-nightly",
+        produce_tool_path(
+            tool_name = "rust-src",
+            version = "nightly",
+            target_triple = None,
+        ),
+    )
+    return unittest.end(env)
+
+produce_tool_suburl_test = unittest.make(_produce_tool_suburl_test_impl)
+produce_tool_path_test = unittest.make(_produce_tool_path_test_impl)
+
+def repository_utils_test_suite(name):
+    unittest.suite(
+        name,
+        produce_tool_suburl_test,
+        produce_tool_path_test,
+    )
diff --git a/third_party/rules_rust/test/unit/rustdoc/BUILD.bazel b/third_party/rules_rust/test/unit/rustdoc/BUILD.bazel
new file mode 100644
index 0000000..f4375c3
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":rustdoc_unit_test.bzl", "rustdoc_test_suite")
+
+rustdoc_test_suite(
+    name = "rustdoc_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc.cc b/third_party/rules_rust/test/unit/rustdoc/rustdoc.cc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc.cc
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc.h b/third_party/rules_rust/test/unit/rustdoc/rustdoc.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc.h
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc_bin.rs b/third_party/rules_rust/test/unit/rustdoc/rustdoc_bin.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc_bin.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc_lib.rs b/third_party/rules_rust/test/unit/rustdoc/rustdoc_lib.rs
new file mode 100644
index 0000000..f7b4652
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc_lib.rs
@@ -0,0 +1,25 @@
+#[cfg(feature = "with_proc_macro")]
+use rustdoc_proc_macro::make_answer;
+
+#[cfg(feature = "with_proc_macro")]
+make_answer!();
+
+/// The answer to the ultimate question
+/// ```
+/// fn answer() -> u32 { 42 }
+/// assert_eq!(answer(), 42);
+/// ```
+#[cfg(not(feature = "with_proc_macro"))]
+pub fn answer() -> u32 {
+    42
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_answer() {
+        assert_eq!(answer(), 42);
+    }
+}
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc_proc_macro.rs b/third_party/rules_rust/test/unit/rustdoc/rustdoc_proc_macro.rs
new file mode 100644
index 0000000..ccc9fb9
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc_proc_macro.rs
@@ -0,0 +1,14 @@
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn make_answer(_item: TokenStream) -> TokenStream {
+    "\
+/// A procedural macro example:
+/// ```
+/// fn answer() -> u32 { 42 }
+/// assert_eq!(answer(), 42);
+/// ```
+pub fn answer() -> u32 { 42 }"
+        .parse()
+        .unwrap()
+}
diff --git a/third_party/rules_rust/test/unit/rustdoc/rustdoc_unit_test.bzl b/third_party/rules_rust/test/unit/rustdoc/rustdoc_unit_test.bzl
new file mode 100644
index 0000000..6d7a6ed
--- /dev/null
+++ b/third_party/rules_rust/test/unit/rustdoc/rustdoc_unit_test.bzl
@@ -0,0 +1,197 @@
+"""Unittest to verify properties of rustdoc rules"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//rust:defs.bzl", "rust_binary", "rust_doc", "rust_doc_test", "rust_library", "rust_proc_macro", "rust_test")
+load(
+    "//test/unit:common.bzl",
+    "assert_action_mnemonic",
+    "assert_argv_contains_prefix_not",
+)
+
+def _common_rustdoc_checks(env, tut):
+    actions = tut.actions
+    action = actions[0]
+    assert_action_mnemonic(env, action, "Rustdoc")
+
+    # These flags, while required for `Rustc` actions, should be omitted for
+    # `Rustdoc` actions
+    assert_argv_contains_prefix_not(env, action, "--remap-path-prefix")
+    assert_argv_contains_prefix_not(env, action, "--emit")
+
+def _rustdoc_for_lib_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+def _rustdoc_for_bin_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+def _rustdoc_for_proc_macro_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+def _rustdoc_for_lib_with_proc_macro_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+def _rustdoc_for_bin_with_transitive_proc_macro_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+def _rustdoc_for_lib_with_cc_lib_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+
+    _common_rustdoc_checks(env, tut)
+
+    return analysistest.end(env)
+
+rustdoc_for_lib_test = analysistest.make(_rustdoc_for_lib_test_impl)
+rustdoc_for_bin_test = analysistest.make(_rustdoc_for_bin_test_impl)
+rustdoc_for_proc_macro_test = analysistest.make(_rustdoc_for_proc_macro_test_impl)
+rustdoc_for_lib_with_proc_macro_test = analysistest.make(_rustdoc_for_lib_with_proc_macro_test_impl)
+rustdoc_for_bin_with_transitive_proc_macro_test = analysistest.make(_rustdoc_for_bin_with_transitive_proc_macro_test_impl)
+rustdoc_for_lib_with_cc_lib_test = analysistest.make(_rustdoc_for_lib_with_cc_lib_test_impl)
+
+def _target_maker(rule_fn, name, **kwargs):
+    rule_fn(
+        name = name,
+        **kwargs
+    )
+
+    rust_test(
+        name = "{}_test".format(name),
+        crate = ":{}".format(name),
+    )
+
+    rust_doc(
+        name = "{}_doc".format(name),
+        crate = ":{}".format(name),
+    )
+
+    rust_doc_test(
+        name = "{}_doctest".format(name),
+        crate = ":{}".format(name),
+    )
+
+def _define_targets():
+    _target_maker(
+        rust_binary,
+        name = "bin",
+        srcs = ["rustdoc_bin.rs"],
+    )
+
+    _target_maker(
+        rust_library,
+        name = "lib",
+        srcs = ["rustdoc_lib.rs"],
+    )
+
+    _target_maker(
+        rust_proc_macro,
+        name = "rustdoc_proc_macro",
+        srcs = ["rustdoc_proc_macro.rs"],
+        edition = "2018",
+    )
+
+    _target_maker(
+        rust_library,
+        name = "lib_with_proc_macro",
+        srcs = ["rustdoc_lib.rs"],
+        proc_macro_deps = [":rustdoc_proc_macro"],
+        crate_features = ["with_proc_macro"],
+    )
+
+    _target_maker(
+        rust_binary,
+        name = "bin_with_transitive_proc_macro",
+        srcs = ["rustdoc_bin.rs"],
+        deps = [":lib_with_proc_macro"],
+        proc_macro_deps = [":rustdoc_proc_macro"],
+        crate_features = ["with_proc_macro"],
+    )
+
+    cc_library(
+        name = "cc_lib",
+        hdrs = ["rustdoc.h"],
+        srcs = ["rustdoc.cc"],
+    )
+
+    _target_maker(
+        rust_library,
+        name = "lib_with_cc",
+        srcs = ["rustdoc_lib.rs"],
+        crate_features = ["with_cc"],
+        deps = [":cc_lib"],
+    )
+
+def rustdoc_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+
+    _define_targets()
+
+    rustdoc_for_lib_test(
+        name = "rustdoc_for_lib_test",
+        target_under_test = ":lib_doc",
+    )
+
+    rustdoc_for_bin_test(
+        name = "rustdoc_for_bin_test",
+        target_under_test = ":bin_doc",
+    )
+
+    rustdoc_for_proc_macro_test(
+        name = "rustdoc_for_proc_macro_test",
+        target_under_test = ":rustdoc_proc_macro_doc",
+    )
+
+    rustdoc_for_lib_with_proc_macro_test(
+        name = "rustdoc_for_lib_with_proc_macro_test",
+        target_under_test = ":lib_with_proc_macro_doc",
+    )
+
+    rustdoc_for_bin_with_transitive_proc_macro_test(
+        name = "rustdoc_for_bin_with_transitive_proc_macro_test",
+        target_under_test = ":bin_with_transitive_proc_macro_doc",
+    )
+
+    rustdoc_for_lib_with_cc_lib_test(
+        name = "rustdoc_for_lib_with_cc_lib_test",
+        target_under_test = ":lib_with_cc_doc",
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":rustdoc_for_lib_test",
+            ":rustdoc_for_bin_test",
+            ":rustdoc_for_proc_macro_test",
+            ":rustdoc_for_lib_with_proc_macro_test",
+            ":rustdoc_for_lib_with_cc_lib_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/stamp/BUILD.bazel b/third_party/rules_rust/test/unit/stamp/BUILD.bazel
new file mode 100644
index 0000000..0ba3cf0
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stamp/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":stamp_test.bzl", "stamp_test_suite")
+
+stamp_test_suite(
+    name = "stamp_test_suite",
+)
diff --git a/third_party/rules_rust/test/unit/stamp/stamp.env b/third_party/rules_rust/test/unit/stamp/stamp.env
new file mode 100644
index 0000000..818c4a0
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stamp/stamp.env
@@ -0,0 +1,2 @@
+BUILD_TIMESTAMP={BUILD_TIMESTAMP}
+BUILD_USER={BUILD_USER}
diff --git a/third_party/rules_rust/test/unit/stamp/stamp.rs b/third_party/rules_rust/test/unit/stamp/stamp.rs
new file mode 100644
index 0000000..cb80052
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stamp/stamp.rs
@@ -0,0 +1,37 @@
+//! A small test library for ensuring `--stamp` data is correctly set at compile time.
+
+pub fn build_timestamp() -> &'static str {
+    env!("BUILD_TIMESTAMP")
+}
+
+pub fn build_user() -> &'static str {
+    env!("BUILD_USER")
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[cfg(feature = "force_stamp")]
+    #[test]
+    fn stamp_resolved() {
+        assert!(!build_timestamp().contains("BUILD_TIMESTAMP"));
+        assert!(build_timestamp().chars().all(char::is_numeric));
+    }
+
+    #[cfg(feature = "skip_stamp")]
+    #[test]
+    fn stamp_not_resolved() {
+        assert!(build_timestamp().contains("BUILD_TIMESTAMP"));
+    }
+
+    #[test]
+    fn lib_volatile_stamp_matches() {
+        assert_eq!(build_timestamp(), env!("BUILD_TIMESTAMP"));
+    }
+
+    #[test]
+    fn lib_stable_stamp_not_stamped() {
+        assert_eq!(build_user(), "{BUILD_USER}");
+    }
+}
diff --git a/third_party/rules_rust/test/unit/stamp/stamp_main.rs b/third_party/rules_rust/test/unit/stamp/stamp_main.rs
new file mode 100644
index 0000000..0e8b963
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stamp/stamp_main.rs
@@ -0,0 +1,10 @@
+#[cfg(feature = "force_stamp")]
+use force_stamp::build_timestamp;
+
+#[cfg(feature = "skip_stamp")]
+use skip_stamp::build_timestamp;
+
+fn main() {
+    println!("bin stamp: {}", env!("BUILD_TIMESTAMP"));
+    println!("lib stamp: {}", build_timestamp());
+}
diff --git a/third_party/rules_rust/test/unit/stamp/stamp_test.bzl b/third_party/rules_rust/test/unit/stamp/stamp_test.bzl
new file mode 100644
index 0000000..18251e1
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stamp/stamp_test.bzl
@@ -0,0 +1,122 @@
+"""Unittest to verify workspace status stamping is applied to environment files"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
+load(
+    "//test/unit:common.bzl",
+    "assert_action_mnemonic",
+    "assert_argv_contains",
+    "assert_argv_contains_not",
+)
+
+def _stamp_test_impl(ctx, force_stamp):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    action = target.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+
+    if force_stamp:
+        assert_argv_contains(env, action, "--volatile-status-file")
+        assert_argv_contains(env, action, "bazel-out/volatile-status.txt")
+    else:
+        assert_argv_contains_not(env, action, "--volatile-status-file")
+        assert_argv_contains_not(env, action, "bazel-out/volatile-status.txt")
+
+    # Note that use of stable status invalidates targets any time it's updated.
+    # This is undesirable behavior so it's intended to be excluded from the
+    # Rustc action. In general this should be fine as other rules can be used
+    # to produce template files for stamping in this action (ie. genrule).
+    assert_argv_contains_not(env, action, "bazel-out/stable-status.txt")
+
+    return analysistest.end(env)
+
+def _force_stamp_test_impl(ctx):
+    return _stamp_test_impl(ctx, True)
+
+def _skip_stamp_test_impl(ctx):
+    return _stamp_test_impl(ctx, False)
+
+force_stamp_test = analysistest.make(_force_stamp_test_impl)
+skip_stamp_test = analysistest.make(_skip_stamp_test_impl)
+
+_STAMP_VALUES = (0, 1)
+
+def _define_test_targets():
+    for stamp_value in _STAMP_VALUES:
+        if stamp_value == 1:
+            name = "force_stamp"
+            features = ["force_stamp"]
+        else:
+            name = "skip_stamp"
+            features = ["skip_stamp"]
+
+        rust_library(
+            name = name,
+            srcs = ["stamp.rs"],
+            edition = "2018",
+            rustc_env_files = [":stamp.env"],
+            stamp = stamp_value,
+            crate_features = features,
+        )
+
+        rust_test(
+            name = "{}_unit_test".format(name),
+            crate = ":{}".format(name),
+            rustc_env_files = [":stamp.env"],
+            stamp = stamp_value,
+            crate_features = features,
+        )
+
+        rust_binary(
+            name = "{}_bin".format(name),
+            srcs = ["stamp_main.rs"],
+            deps = [":{}".format(name)],
+            rustc_env_files = [":stamp.env"],
+            stamp = stamp_value,
+            crate_features = features,
+        )
+
+def stamp_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name (str): Name of the macro.
+    """
+    _define_test_targets()
+
+    tests = []
+
+    for stamp_value in _STAMP_VALUES:
+        if stamp_value == 1:
+            test_name = "force_stamp"
+            stamp_test = force_stamp_test
+        else:
+            test_name = "skip_stamp"
+            stamp_test = skip_stamp_test
+
+        stamp_test(
+            name = "lib_{}_test".format(test_name),
+            target_under_test = Label("//test/unit/stamp:{}".format(test_name)),
+        )
+
+        stamp_test(
+            name = "test_{}_test".format(test_name),
+            target_under_test = Label("//test/unit/stamp:{}_unit_test".format(test_name)),
+        )
+
+        stamp_test(
+            name = "bin_{}_test".format(test_name),
+            target_under_test = Label("//test/unit/stamp:{}_bin".format(test_name)),
+        )
+
+        tests.extend([
+            "lib_{}_test".format(test_name),
+            "test_{}_test".format(test_name),
+            "bin_{}_test".format(test_name),
+        ])
+
+    native.test_suite(
+        name = name,
+        tests = tests,
+    )
diff --git a/third_party/rules_rust/test/unit/stdlib/BUILD.bazel b/third_party/rules_rust/test/unit/stdlib/BUILD.bazel
new file mode 100644
index 0000000..3907b2e
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stdlib/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":stdlib.bzl", "stdlib_suite")
+
+############################ UNIT TESTS #############################
+stdlib_suite(name = "stdlib_suite")
diff --git a/third_party/rules_rust/test/unit/stdlib/some_rlib.rs b/third_party/rules_rust/test/unit/stdlib/some_rlib.rs
new file mode 100644
index 0000000..4a57a27
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stdlib/some_rlib.rs
@@ -0,0 +1,3 @@
+pub fn print_stuff() {
+    println!("stuff");
+}
diff --git a/third_party/rules_rust/test/unit/stdlib/stdlib.bzl b/third_party/rules_rust/test/unit/stdlib/stdlib.bzl
new file mode 100644
index 0000000..9d83190
--- /dev/null
+++ b/third_party/rules_rust/test/unit/stdlib/stdlib.bzl
@@ -0,0 +1,93 @@
+"""Unittest to verify contents and ordering of rust stdlib in rust_library() CcInfo"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_library")
+
+def _categorize_library(name):
+    """Given an rlib name, guess if it's std, core, or alloc."""
+    if "std" in name:
+        return "std"
+    if "core" in name:
+        return "core"
+    if "alloc" in name:
+        return "alloc"
+    if "compiler_builtins" in name:
+        return "compiler_builtins"
+    return "other"
+
+def _dedup_preserving_order(list):
+    """Given a list, deduplicate its elements preserving order."""
+    r = []
+    seen = {}
+    for e in list:
+        if e in seen:
+            continue
+        seen[e] = 1
+        r.append(e)
+    return r
+
+def _stdlibs(tut):
+    """Given a target, return the list of its standard rust libraries."""
+    libs = [
+        lib.static_library
+        for li in tut[CcInfo].linking_context.linker_inputs.to_list()
+        for lib in li.libraries
+    ]
+    stdlibs = [lib for lib in libs if (tut.label.name not in lib.basename)]
+    return stdlibs
+
+def _libstd_ordering_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    stdlib_categories = [_categorize_library(lib.basename) for lib in _stdlibs(tut)]
+    set_to_check = _dedup_preserving_order([lib for lib in stdlib_categories if lib != "other"])
+    asserts.equals(env, ["std", "core", "compiler_builtins", "alloc"], set_to_check)
+    return analysistest.end(env)
+
+libstd_ordering_test = analysistest.make(_libstd_ordering_test_impl)
+
+def _libstd_panic_test_impl(ctx):
+    # The libraries panic_unwind and panic_abort are alternatives.
+    # Check that they don't occur together.
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    stdlibs = _stdlibs(tut)
+    has_panic_unwind = [lib for lib in stdlibs if "panic_unwind" in lib.basename]
+    if has_panic_unwind:
+        has_panic_abort = [lib for lib in stdlibs if "panic_abort" in lib.basename]
+        asserts.false(env, has_panic_abort)
+
+    return analysistest.end(env)
+
+libstd_panic_test = analysistest.make(_libstd_panic_test_impl)
+
+def _native_dep_test():
+    rust_library(
+        name = "some_rlib",
+        srcs = ["some_rlib.rs"],
+    )
+
+    libstd_ordering_test(
+        name = "libstd_ordering_test",
+        target_under_test = ":some_rlib",
+    )
+
+    libstd_panic_test(
+        name = "libstd_panic_test",
+        target_under_test = ":some_rlib",
+    )
+
+def stdlib_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _native_dep_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":libstd_ordering_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/toolchain/BUILD.bazel b/third_party/rules_rust/test/unit/toolchain/BUILD.bazel
new file mode 100644
index 0000000..b427172
--- /dev/null
+++ b/third_party/rules_rust/test/unit/toolchain/BUILD.bazel
@@ -0,0 +1,3 @@
+load(":toolchain_test.bzl", "toolchain_test_suite")
+
+toolchain_test_suite(name = "toolchain_test_suite")
diff --git a/third_party/rules_rust/test/unit/toolchain/config.txt b/third_party/rules_rust/test/unit/toolchain/config.txt
new file mode 100644
index 0000000..8378bfb
--- /dev/null
+++ b/third_party/rules_rust/test/unit/toolchain/config.txt
@@ -0,0 +1 @@
+a source of the stdlib
diff --git a/third_party/rules_rust/test/unit/toolchain/toolchain-test-triple.json b/third_party/rules_rust/test/unit/toolchain/toolchain-test-triple.json
new file mode 100644
index 0000000..1098428
--- /dev/null
+++ b/third_party/rules_rust/test/unit/toolchain/toolchain-test-triple.json
@@ -0,0 +1,34 @@
+{
+  "arch": "x86_64",
+  "cpu": "x86-64",
+  "crt-static-respected": true,
+  "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
+  "dynamic-linking": true,
+  "env": "gnu",
+  "executables": true,
+  "has-elf-tls": true,
+  "has-rpath": true,
+  "llvm-target": "x86_64-unknown-linux-gnu",
+  "max-atomic-width": 64,
+  "os": "linux",
+  "position-independent-executables": true,
+  "pre-link-args": {
+    "gcc": [
+      "-m64"
+    ]
+  },
+  "relro-level": "full",
+  "stack-probes": {
+    "kind": "call"
+  },
+  "supported-sanitizers": [
+    "address",
+    "leak",
+    "memory",
+    "thread"
+  ],
+  "target-family": [
+    "unix"
+  ],
+  "target-pointer-width": "64"
+}
diff --git a/third_party/rules_rust/test/unit/toolchain/toolchain_test.bzl b/third_party/rules_rust/test/unit/toolchain/toolchain_test.bzl
new file mode 100644
index 0000000..2e6d208
--- /dev/null
+++ b/third_party/rules_rust/test/unit/toolchain/toolchain_test.bzl
@@ -0,0 +1,137 @@
+"""Unit tests for rust toolchains."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("//rust:toolchain.bzl", "rust_stdlib_filegroup", "rust_toolchain")
+
+def _toolchain_specifies_target_triple_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    toolchain_info = analysistest.target_under_test(env)[platform_common.ToolchainInfo]
+
+    asserts.equals(env, None, toolchain_info.target_json)
+    asserts.equals(env, "toolchain-test-triple", toolchain_info.target_flag_value)
+    asserts.equals(env, "toolchain-test-triple", toolchain_info.target_triple)
+
+    return analysistest.end(env)
+
+def _toolchain_specifies_target_json_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    toolchain_info = analysistest.target_under_test(env)[platform_common.ToolchainInfo]
+
+    asserts.equals(env, "toolchain-test-triple.json", toolchain_info.target_json.basename)
+    asserts.equals(env, "test/unit/toolchain/toolchain-test-triple.json", toolchain_info.target_flag_value)
+    asserts.equals(env, "", toolchain_info.target_triple)
+
+    return analysistest.end(env)
+
+def _toolchain_location_expands_linkflags_impl(ctx):
+    env = analysistest.begin(ctx)
+    toolchain_info = analysistest.target_under_test(env)[platform_common.ToolchainInfo]
+
+    asserts.equals(
+        env,
+        "test:test/unit/toolchain/config.txt",
+        toolchain_info.stdlib_linkflags.linking_context.linker_inputs.to_list()[0].user_link_flags[0],
+    )
+
+    return analysistest.end(env)
+
+toolchain_specifies_target_triple_test = analysistest.make(_toolchain_specifies_target_triple_test_impl)
+toolchain_specifies_target_json_test = analysistest.make(_toolchain_specifies_target_json_test_impl)
+toolchain_location_expands_linkflags_test = analysistest.make(_toolchain_location_expands_linkflags_impl)
+
+def _toolchain_test():
+    native.filegroup(
+        name = "stdlib_srcs",
+        srcs = ["config.txt"],
+    )
+    rust_stdlib_filegroup(
+        name = "std_libs",
+        srcs = [":stdlib_srcs"],
+    )
+
+    native.filegroup(
+        name = "target_json",
+        srcs = ["toolchain-test-triple.json"],
+    )
+
+    write_file(
+        name = "mock_rustc",
+        out = "mock_rustc.exe",
+        content = [],
+        is_executable = True,
+    )
+
+    write_file(
+        name = "mock_rustdoc",
+        out = "mock_rustdoc.exe",
+        content = [],
+        is_executable = True,
+    )
+
+    rust_toolchain(
+        name = "rust_triple_toolchain",
+        binary_ext = "",
+        dylib_ext = ".so",
+        exec_triple = "x86_64-unknown-none",
+        os = "linux",
+        rust_doc = ":mock_rustdoc",
+        rust_std = ":std_libs",
+        rustc = ":mock_rustc",
+        staticlib_ext = ".a",
+        stdlib_linkflags = [],
+        target_triple = "toolchain-test-triple",
+    )
+
+    rust_toolchain(
+        name = "rust_json_toolchain",
+        binary_ext = "",
+        dylib_ext = ".so",
+        exec_triple = "x86_64-unknown-none",
+        os = "linux",
+        rust_doc = ":mock_rustdoc",
+        rust_std = ":std_libs",
+        rustc = ":mock_rustc",
+        staticlib_ext = ".a",
+        stdlib_linkflags = [],
+        target_json = ":target_json",
+    )
+
+    rust_toolchain(
+        name = "rust_location_expand_toolchain",
+        binary_ext = "",
+        dylib_ext = ".so",
+        exec_triple = "x86_64-unknown-none",
+        os = "linux",
+        rust_doc = ":mock_rustdoc",
+        rust_std = ":std_libs",
+        rustc = ":mock_rustc",
+        staticlib_ext = ".a",
+        stdlib_linkflags = ["test:$(location :stdlib_srcs)"],
+        target_json = ":target_json",
+    )
+
+    toolchain_specifies_target_triple_test(
+        name = "toolchain_specifies_target_triple_test",
+        target_under_test = ":rust_triple_toolchain",
+    )
+    toolchain_specifies_target_json_test(
+        name = "toolchain_specifies_target_json_test",
+        target_under_test = ":rust_json_toolchain",
+    )
+    toolchain_location_expands_linkflags_test(
+        name = "toolchain_location_expands_linkflags_test",
+        target_under_test = ":rust_location_expand_toolchain",
+    )
+
+def toolchain_test_suite(name):
+    _toolchain_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":toolchain_specifies_target_triple_test",
+            ":toolchain_specifies_target_json_test",
+            ":toolchain_location_expands_linkflags_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/transitive_crate_outputs/BUILD.bazel b/third_party/rules_rust/test/unit/transitive_crate_outputs/BUILD.bazel
new file mode 100644
index 0000000..9d2da52
--- /dev/null
+++ b/third_party/rules_rust/test/unit/transitive_crate_outputs/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":transitive_crate_outputs_test.bzl", "transitive_crate_outputs_test_suite")
+
+############################ UNIT TESTS #############################
+transitive_crate_outputs_test_suite(name = "transitive_crate_outputs_test_suite")
diff --git a/third_party/rules_rust/test/unit/transitive_crate_outputs/bar.rs b/third_party/rules_rust/test/unit/transitive_crate_outputs/bar.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/transitive_crate_outputs/bar.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/transitive_crate_outputs/baz.cc b/third_party/rules_rust/test/unit/transitive_crate_outputs/baz.cc
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/transitive_crate_outputs/baz.cc
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/transitive_crate_outputs/foo.rs b/third_party/rules_rust/test/unit/transitive_crate_outputs/foo.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/transitive_crate_outputs/foo.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/transitive_crate_outputs/transitive_crate_outputs_test.bzl b/third_party/rules_rust/test/unit/transitive_crate_outputs/transitive_crate_outputs_test.bzl
new file mode 100644
index 0000000..8662185
--- /dev/null
+++ b/third_party/rules_rust/test/unit/transitive_crate_outputs/transitive_crate_outputs_test.bzl
@@ -0,0 +1,56 @@
+"""Unittests for rust rules."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("//rust:defs.bzl", "rust_common", "rust_library")
+
+def _transitive_crate_outputs_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    transitive_crate_outputs = tut[rust_common.dep_info].transitive_crate_outputs.to_list()
+
+    # Check that the non-crate output baz.a didn't find its way into transitive_crate_outputs
+    # while the bar.rlib did.
+    asserts.equals(env, len(transitive_crate_outputs), 1)
+    asserts.equals(env, transitive_crate_outputs[0].extension, "rlib")
+
+    return analysistest.end(env)
+
+transitive_crate_outputs_test = analysistest.make(_transitive_crate_outputs_test_impl)
+
+def _transitive_crate_outputs_test():
+    rust_library(
+        name = "foo",
+        srcs = ["foo.rs"],
+        deps = [":bar", ":baz"],
+    )
+
+    rust_library(
+        name = "bar",
+        srcs = ["bar.rs"],
+    )
+
+    # buildifier: disable=native-cc
+    native.cc_library(
+        name = "baz",
+        srcs = ["baz.cc"],
+    )
+
+    transitive_crate_outputs_test(
+        name = "transitive_crate_outputs_test",
+        target_under_test = ":foo",
+    )
+
+def transitive_crate_outputs_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _transitive_crate_outputs_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":transitive_crate_outputs_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/use_libtest_harness/BUILD.bazel b/third_party/rules_rust/test/unit/use_libtest_harness/BUILD.bazel
new file mode 100644
index 0000000..eb91951
--- /dev/null
+++ b/third_party/rules_rust/test/unit/use_libtest_harness/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":use_libtest_harness_test.bzl", "use_libtest_harness_test_suite")
+
+############################ UNIT TESTS #############################
+use_libtest_harness_test_suite(name = "use_libtest_harness_test_suite")
diff --git a/third_party/rules_rust/test/unit/use_libtest_harness/mytest.rs b/third_party/rules_rust/test/unit/use_libtest_harness/mytest.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/rules_rust/test/unit/use_libtest_harness/mytest.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/rules_rust/test/unit/use_libtest_harness/mytest_noharness.rs b/third_party/rules_rust/test/unit/use_libtest_harness/mytest_noharness.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/use_libtest_harness/mytest_noharness.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/third_party/rules_rust/test/unit/use_libtest_harness/use_libtest_harness_test.bzl b/third_party/rules_rust/test/unit/use_libtest_harness/use_libtest_harness_test.bzl
new file mode 100644
index 0000000..fd7907d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/use_libtest_harness/use_libtest_harness_test.bzl
@@ -0,0 +1,65 @@
+"""Unittest to verify ordering of rust stdlib in rust_library() CcInfo"""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest")
+load("//rust:defs.bzl", "rust_test")
+load("//test/unit:common.bzl", "assert_action_mnemonic", "assert_argv_contains", "assert_argv_contains_not", "assert_list_contains_adjacent_elements", "assert_list_contains_adjacent_elements_not")
+
+def _use_libtest_harness_rustc_flags_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    assert_argv_contains(env, action, "test/unit/use_libtest_harness/mytest.rs")
+    assert_argv_contains(env, action, "--test")
+    assert_list_contains_adjacent_elements_not(env, action.argv, ["--cfg", "test"])
+    return analysistest.end(env)
+
+def _use_libtest_harness_rustc_noharness_flags_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    action = tut.actions[0]
+    assert_action_mnemonic(env, action, "Rustc")
+    assert_argv_contains(env, action, "test/unit/use_libtest_harness/mytest_noharness.rs")
+    assert_argv_contains_not(env, action, "--test")
+    assert_list_contains_adjacent_elements(env, action.argv, ["--cfg", "test"])
+    return analysistest.end(env)
+
+use_libtest_harness_rustc_flags_test = analysistest.make(_use_libtest_harness_rustc_flags_test_impl)
+use_libtest_harness_rustc_noharness_flags_test = analysistest.make(_use_libtest_harness_rustc_noharness_flags_test_impl)
+
+def _use_libtest_harness_test():
+    rust_test(
+        name = "mytest",
+        srcs = ["mytest.rs"],
+    )
+
+    rust_test(
+        name = "mytest_noharness",
+        srcs = ["mytest_noharness.rs"],
+        use_libtest_harness = False,
+    )
+
+    use_libtest_harness_rustc_flags_test(
+        name = "use_libtest_harness_rustc_flags_test",
+        target_under_test = ":mytest",
+    )
+
+    use_libtest_harness_rustc_noharness_flags_test(
+        name = "use_libtest_harness_rustc_noharness_flags_test",
+        target_under_test = ":mytest_noharness",
+    )
+
+def use_libtest_harness_test_suite(name):
+    """Entry-point macro called from the BUILD file.
+
+    Args:
+        name: Name of the macro.
+    """
+    _use_libtest_harness_test()
+
+    native.test_suite(
+        name = name,
+        tests = [
+            ":use_libtest_harness_rustc_flags_test",
+        ],
+    )
diff --git a/third_party/rules_rust/test/unit/utils/BUILD.bazel b/third_party/rules_rust/test/unit/utils/BUILD.bazel
new file mode 100644
index 0000000..5867410
--- /dev/null
+++ b/third_party/rules_rust/test/unit/utils/BUILD.bazel
@@ -0,0 +1,3 @@
+load(":utils_test.bzl", "utils_test_suite")
+
+utils_test_suite(name = "utils_tests")
diff --git a/third_party/rules_rust/test/unit/utils/utils_test.bzl b/third_party/rules_rust/test/unit/utils/utils_test.bzl
new file mode 100644
index 0000000..dd7bbe5
--- /dev/null
+++ b/third_party/rules_rust/test/unit/utils/utils_test.bzl
@@ -0,0 +1,88 @@
+""" Unit tests for functions defined in utils.bzl. """
+
+load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "decode_crate_name_as_label_for_testing", "encode_label_as_crate_name", "should_encode_label_in_crate_name")
+
+def _encode_label_as_crate_name_test_impl(ctx):
+    env = unittest.begin(ctx)
+
+    # Typical cases.
+    asserts.equals(
+        env,
+        "x_slash_y_colon_z",
+        encode_label_as_crate_name("x/y", "z"),
+    )
+    asserts.equals(
+        env,
+        "some_slash_package_colon_target",
+        encode_label_as_crate_name("some/package", "target"),
+    )
+
+    # Target name includes a character illegal in crate names.
+    asserts.equals(
+        env,
+        "some_slash_package_colon_foo_slash_target",
+        encode_label_as_crate_name("some/package", "foo/target"),
+    )
+
+    # Package/target includes some of the encodings.
+    asserts.equals(
+        env,
+        "some_quoteslash__slash_package_colon_target_quotedot_foo",
+        encode_label_as_crate_name("some_slash_/package", "target_dot_foo"),
+    )
+
+    # Some pathological cases: test that round-tripping the encoding works as
+    # expected.
+
+    # Label includes a quoted encoding.
+    package = "_quotedot_"
+    target = "target"
+    asserts.equals(env, "_quotequote_dot__colon_target", encode_label_as_crate_name(package, target))
+    asserts.equals(env, package + ":" + target, decode_crate_name_as_label_for_testing(encode_label_as_crate_name(package, target)))
+
+    package = "x_slash_y"
+    target = "z"
+    asserts.equals(env, "x_quoteslash_y_colon_z", encode_label_as_crate_name(package, target))
+    asserts.equals(env, package + ":" + target, decode_crate_name_as_label_for_testing(encode_label_as_crate_name(package, target)))
+
+    # Package is identical to a valid encoding already.
+    package = "_quotequote_dot__colon_target"
+    target = "target"
+    asserts.equals(env, "_quotequote_quote_quotedot__quotecolon_target_colon_target", encode_label_as_crate_name(package, target))
+    asserts.equals(env, package + ":" + target, decode_crate_name_as_label_for_testing(encode_label_as_crate_name(package, target)))
+    return unittest.end(env)
+
+def _is_third_party_crate_test_impl(ctx):
+    env = unittest.begin(ctx)
+
+    # A target at the root of the third-party dir is considered third-party:
+    asserts.false(env, should_encode_label_in_crate_name("some_workspace", Label("//third_party:foo"), "//third_party"))
+
+    # Targets in subpackages are detected properly:
+    asserts.false(env, should_encode_label_in_crate_name("some_workspace", Label("//third_party/serde:serde"), "//third_party"))
+    asserts.false(env, should_encode_label_in_crate_name("some_workspace", Label("//third_party/serde/v1:serde"), "//third_party"))
+
+    # Ensure the directory name truly matches, and doesn't just include the
+    # third-party dir as a substring (or vice versa).
+    asserts.true(env, should_encode_label_in_crate_name("some_workspace", Label("//third_party_decoy:thing"), "//third_party"))
+    asserts.true(env, should_encode_label_in_crate_name("some_workspace", Label("//decoy_third_party:thing"), "//third_party"))
+    asserts.true(env, should_encode_label_in_crate_name("some_workspace", Label("//third_:thing"), "//third_party"))
+    asserts.true(env, should_encode_label_in_crate_name("some_workspace", Label("//third_party_decoy/serde:serde"), "//third_party"))
+
+    # Targets in rules_rust's repo should never be renamed.
+    asserts.false(env, should_encode_label_in_crate_name("rules_rust", Label("//some_package:foo"), "//third_party"))
+
+    return unittest.end(env)
+
+encode_label_as_crate_name_test = unittest.make(_encode_label_as_crate_name_test_impl)
+is_third_party_crate_test = unittest.make(_is_third_party_crate_test_impl)
+
+def utils_test_suite(name):
+    unittest.suite(
+        name,
+        encode_label_as_crate_name_test,
+        is_third_party_crate_test,
+    )
diff --git a/third_party/rules_rust/test/unit/versioned_libs/BUILD.bazel b/third_party/rules_rust/test/unit/versioned_libs/BUILD.bazel
new file mode 100644
index 0000000..b90a8ef
--- /dev/null
+++ b/third_party/rules_rust/test/unit/versioned_libs/BUILD.bazel
@@ -0,0 +1,7 @@
+load(":versioned_libs_analysis_test.bzl", "versioned_libs_analysis_test_suite")
+load(":versioned_libs_unit_test.bzl", "versioned_libs_unit_test_suite")
+
+############################ UNIT TESTS #############################
+versioned_libs_unit_test_suite(name = "versioned_libs_unit_test_suite")
+
+versioned_libs_analysis_test_suite(name = "versioned_libs_analysis_test_suite")
diff --git a/third_party/rules_rust/test/unit/versioned_libs/a.rs b/third_party/rules_rust/test/unit/versioned_libs/a.rs
new file mode 100644
index 0000000..421e195
--- /dev/null
+++ b/third_party/rules_rust/test/unit/versioned_libs/a.rs
@@ -0,0 +1 @@
+pub fn hello() {}
diff --git a/third_party/rules_rust/test/unit/versioned_libs/b.c b/third_party/rules_rust/test/unit/versioned_libs/b.c
new file mode 100644
index 0000000..03e9bbf
--- /dev/null
+++ b/third_party/rules_rust/test/unit/versioned_libs/b.c
@@ -0,0 +1 @@
+void hello(void) {}
diff --git a/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_analysis_test.bzl b/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_analysis_test.bzl
new file mode 100644
index 0000000..f31d390
--- /dev/null
+++ b/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_analysis_test.bzl
@@ -0,0 +1,233 @@
+"""Analysis tests for getting the link name of a versioned library."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@bazel_skylib//rules:copy_file.bzl", "copy_file")
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_import")
+load("//rust:defs.bzl", "rust_shared_library")
+
+LIBNAMES = ["sterling", "cheryl", "lana", "pam", "malory", "cyril"]
+
+def _is_in_argv(argv, version = None):
+    return any(["-ldylib={}{}".format(name, version or "") in argv for name in LIBNAMES])
+
+def _no_version_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    argv = tut.actions[0].argv
+
+    asserts.true(env, _is_in_argv(argv))
+
+    return analysistest.end(env)
+
+def _prefix_version_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    argv = tut.actions[0].argv
+
+    asserts.true(env, _is_in_argv(argv, "3.8"))
+
+    return analysistest.end(env)
+
+def _suffix_version_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    tut = analysistest.target_under_test(env)
+    argv = tut.actions[0].argv
+
+    asserts.true(env, _is_in_argv(argv))
+
+    return analysistest.end(env)
+
+no_version_test = analysistest.make(_no_version_test_impl)
+prefix_version_test = analysistest.make(_prefix_version_test_impl)
+suffix_version_test = analysistest.make(_suffix_version_test_impl)
+
+def _test_linux():
+    rust_shared_library(
+        name = "linux_no_version",
+        srcs = ["a.rs"],
+        deps = [":import_libsterling.so"],
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+    cc_import(
+        name = "import_libsterling.so",
+        shared_library = "libsterling.so",
+    )
+    cc_binary(
+        name = "libsterling.so",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    no_version_test(
+        name = "linux_no_version_test",
+        target_under_test = ":linux_no_version",
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+
+    rust_shared_library(
+        name = "linux_suffix_version",
+        srcs = ["a.rs"],
+        deps = [":import_libcheryl.so.3.8", ":import_libcheryl.so"],
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+    cc_import(
+        name = "import_libcheryl.so.3.8",
+        shared_library = "libcheryl.so.3.8",
+    )
+    cc_binary(
+        name = "libcheryl.so.3.8",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    cc_import(
+        name = "import_libcheryl.so",
+        shared_library = "libcheryl.so",
+    )
+    copy_file(
+        name = "copy_unversioned",
+        src = ":libcheryl.so.3.8",
+        out = "libcheryl.so",
+    )
+    suffix_version_test(
+        name = "linux_suffix_version_test",
+        target_under_test = ":linux_suffix_version",
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+
+    return [
+        ":linux_no_version_test",
+        ":linux_suffix_version_test",
+    ]
+
+def _test_macos():
+    rust_shared_library(
+        name = "no_version",
+        srcs = ["a.rs"],
+        deps = [":import_liblana.dylib"],
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+    cc_import(
+        name = "import_liblana.dylib",
+        shared_library = "liblana.dylib",
+    )
+    cc_binary(
+        name = "liblana.dylib",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    no_version_test(
+        name = "macos_no_version_test",
+        target_under_test = ":no_version",
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+
+    rust_shared_library(
+        name = "prefix_version",
+        srcs = ["a.rs"],
+        deps = [":import_libpam3.8.dylib"],
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+    cc_import(
+        name = "import_libpam3.8.dylib",
+        shared_library = "libpam3.8.dylib",
+    )
+    cc_binary(
+        name = "libpam3.8.dylib",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    prefix_version_test(
+        name = "macos_prefix_version_test",
+        target_under_test = ":prefix_version",
+        target_compatible_with = ["@platforms//os:macos"],
+    )
+
+    return [
+        ":macos_no_version_test",
+        ":macos_prefix_version_test",
+    ]
+
+def _test_windows():
+    rust_shared_library(
+        name = "windows_no_version",
+        srcs = ["a.rs"],
+        deps = [":import_malory.dll"],
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+    cc_import(
+        name = "import_malory.dll",
+        interface_library = ":malory.lib",
+        shared_library = "malory.dll",
+    )
+    cc_binary(
+        name = "malory.dll",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    native.filegroup(
+        name = "malory_interface_lib",
+        srcs = [":malory.dll"],
+        output_group = "interface_library",
+    )
+    copy_file(
+        name = "copy_malory_interface_lib",
+        src = ":malory_interface_lib",
+        out = "malory.lib",
+    )
+    no_version_test(
+        name = "windows_no_version_test",
+        target_under_test = ":windows_no_version",
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    rust_shared_library(
+        name = "windows_prefix_version",
+        srcs = ["a.rs"],
+        deps = [":import_cyril3.8.dll"],
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+    cc_import(
+        name = "import_cyril3.8.dll",
+        interface_library = ":cyril3.8.lib",
+        shared_library = "cyril3.8.dll",
+    )
+    cc_binary(
+        name = "cyril3.8.dll",
+        srcs = ["b.c"],
+        linkshared = True,
+    )
+    native.filegroup(
+        name = "cyril_interface_lib",
+        srcs = [":cyril3.8.dll"],
+        output_group = "interface_library",
+    )
+    copy_file(
+        name = "copy_cyril_interface_lib",
+        src = ":cyril_interface_lib",
+        out = "cyril3.8.lib",
+    )
+    prefix_version_test(
+        name = "windows_prefix_version_test",
+        target_under_test = ":windows_prefix_version",
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    return [
+        ":windows_no_version_test",
+        ":windows_prefix_version_test",
+    ]
+
+def versioned_libs_analysis_test_suite(name):
+    """Analysis tests for getting the link name of a versioned library.
+
+    Args:
+        name: the test suite name
+    """
+    tests = []
+    tests += _test_linux()
+    tests += _test_macos()
+    tests += _test_windows()
+
+    native.test_suite(
+        name = name,
+        tests = tests,
+    )
diff --git a/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_unit_test.bzl b/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_unit_test.bzl
new file mode 100644
index 0000000..0a30525
--- /dev/null
+++ b/third_party/rules_rust/test/unit/versioned_libs/versioned_libs_unit_test.bzl
@@ -0,0 +1,46 @@
+"""Unit tests for getting the link name of a versioned library."""
+
+load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:utils.bzl", "get_lib_name")
+
+def _produced_expected_lib_name_test_impl(ctx):
+    env = unittest.begin(ctx)
+
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.dylib")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.so")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.a")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "python.dll")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "python.lib")))
+
+    asserts.equals(env, "python3", get_lib_name(struct(basename = "libpython3.dylib")))
+    asserts.equals(env, "python3.8", get_lib_name(struct(basename = "libpython3.8.dylib")))
+    asserts.equals(env, "python3", get_lib_name(struct(basename = "libpython3.a")))
+    asserts.equals(env, "python3.8", get_lib_name(struct(basename = "libpython3.8.a")))
+
+    asserts.equals(env, "python38", get_lib_name(struct(basename = "python38.dll")))
+    asserts.equals(env, "python38m", get_lib_name(struct(basename = "python38m.dll")))
+
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.so.3")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.so.3.8")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.so.3.8.0")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.a.3")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.a.3.8")))
+    asserts.equals(env, "python", get_lib_name(struct(basename = "libpython.a.3.8.0")))
+    asserts.equals(env, "python-3.8.0", get_lib_name(struct(basename = "libpython-3.8.0.so.3.8.0")))
+
+    return unittest.end(env)
+
+produced_expected_lib_name_test = unittest.make(_produced_expected_lib_name_test_impl)
+
+def versioned_libs_unit_test_suite(name):
+    """Unit tests for getting the link name of a versioned library.
+
+    Args:
+        name: the test suite name
+    """
+    unittest.suite(
+        name,
+        produced_expected_lib_name_test,
+    )
diff --git a/third_party/rules_rust/test/unit/win_interface_library/BUILD.bazel b/third_party/rules_rust/test/unit/win_interface_library/BUILD.bazel
new file mode 100644
index 0000000..a0a3e19
--- /dev/null
+++ b/third_party/rules_rust/test/unit/win_interface_library/BUILD.bazel
@@ -0,0 +1,4 @@
+load(":win_interface_library_analysis_test.bzl", "win_interface_library_analysis_test_suite")
+
+############################ UNIT TESTS #############################
+win_interface_library_analysis_test_suite(name = "win_interface_library_analysis_test_suite")
diff --git a/third_party/rules_rust/test/unit/win_interface_library/bin.cc b/third_party/rules_rust/test/unit/win_interface_library/bin.cc
new file mode 100644
index 0000000..a3c073a
--- /dev/null
+++ b/third_party/rules_rust/test/unit/win_interface_library/bin.cc
@@ -0,0 +1,6 @@
+extern "C" void hello(void);
+
+int main(int argc, char **argv) {
+    hello();
+    return 0;
+}
diff --git a/third_party/rules_rust/test/unit/win_interface_library/lib.rs b/third_party/rules_rust/test/unit/win_interface_library/lib.rs
new file mode 100644
index 0000000..1f19b6d
--- /dev/null
+++ b/third_party/rules_rust/test/unit/win_interface_library/lib.rs
@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn hello() {
+    println!("Hello");
+}
diff --git a/third_party/rules_rust/test/unit/win_interface_library/main.rs b/third_party/rules_rust/test/unit/win_interface_library/main.rs
new file mode 100644
index 0000000..6d85883
--- /dev/null
+++ b/third_party/rules_rust/test/unit/win_interface_library/main.rs
@@ -0,0 +1,3 @@
+pub fn main() {
+    println!("Hello");
+}
diff --git a/third_party/rules_rust/test/unit/win_interface_library/win_interface_library_analysis_test.bzl b/third_party/rules_rust/test/unit/win_interface_library/win_interface_library_analysis_test.bzl
new file mode 100644
index 0000000..fef00f2
--- /dev/null
+++ b/third_party/rules_rust/test/unit/win_interface_library/win_interface_library_analysis_test.bzl
@@ -0,0 +1,61 @@
+"""Analysis tests for exporting the Windows interface library."""
+
+load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("//rust:defs.bzl", "rust_binary", "rust_shared_library")
+
+def _win_interface_library_test_impl(ctx):
+    env = analysistest.begin(ctx)
+    target = analysistest.target_under_test(env)
+
+    files = target[DefaultInfo].files.to_list()
+    cc_library = target[CcInfo].linking_context.linker_inputs.to_list()[0].libraries[0]
+
+    # Make sure that we have both the `.dll` and the `.dll.lib` file in the default info's files
+    asserts.equals(env, len(files), 2)
+    asserts.true(env, files[0].basename.endswith(".dll"))
+    asserts.true(env, files[1].basename.endswith(".dll.lib"))
+
+    # Make sure that the cc_library has both a dynamic and interface library
+    asserts.true(env, cc_library.dynamic_library != None)
+    asserts.true(env, cc_library.interface_library != None)
+
+    return analysistest.end(env)
+
+win_interface_library_test = analysistest.make(_win_interface_library_test_impl)
+
+def win_interface_library_analysis_test_suite(name):
+    """Analysis tests for exporting the Windows interface library.
+
+    Args:
+        name: the test suite name
+    """
+    rust_shared_library(
+        name = "mylib",
+        srcs = ["lib.rs"],
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    cc_binary(
+        name = "mybin",
+        srcs = ["bin.cc"],
+        deps = [":mylib"],
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    rust_binary(
+        name = "myrustbin",
+        srcs = ["main.rs"],
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    win_interface_library_test(
+        name = "win_interface_library_test",
+        target_under_test = ":mylib",
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    native.test_suite(
+        name = name,
+        tests = [":win_interface_library_test"],
+    )
diff --git a/third_party/rules_rust/test/versioned_dylib/BUILD.bazel b/third_party/rules_rust/test/versioned_dylib/BUILD.bazel
new file mode 100644
index 0000000..a8804e4
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/BUILD.bazel
@@ -0,0 +1,21 @@
+load("//rust:defs.bzl", "rust_binary", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "versioned_dylib",
+    srcs = [
+        "src/main.rs",
+    ],
+    tags = ["manual"],
+    deps = [
+        "//test/versioned_dylib/c:libreturn_zero",
+        "@libc",
+    ],
+)
+
+rust_test(
+    name = "versioned_dylib_test",
+    crate = "versioned_dylib",
+    tags = ["manual"],
+)
diff --git a/third_party/rules_rust/test/versioned_dylib/c/BUILD.bazel b/third_party/rules_rust/test/versioned_dylib/c/BUILD.bazel
new file mode 100644
index 0000000..f944d4c
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/c/BUILD.bazel
@@ -0,0 +1,23 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
+
+[cc_binary(
+    name = "libreturn_zero." + x,
+    srcs = [
+        "return_zero.c",
+        "return_zero.h",
+    ],
+    copts = ["-std=c99"],
+    linkopts = ["-Wl,-soname,libreturn_zero.so.2"],
+    linkshared = True,
+    tags = ["manual"],
+) for x in ("so", "so.2")]
+
+cc_library(
+    name = "libreturn_zero",
+    srcs = [
+        ":libreturn_zero.so",
+        ":libreturn_zero.so.2",
+    ],
+    tags = ["manual"],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/test/versioned_dylib/c/libreturn_zero.so b/third_party/rules_rust/test/versioned_dylib/c/libreturn_zero.so
new file mode 100755
index 0000000..b595ca6
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/c/libreturn_zero.so
Binary files differ
diff --git a/third_party/rules_rust/test/versioned_dylib/c/return_zero.c b/third_party/rules_rust/test/versioned_dylib/c/return_zero.c
new file mode 100644
index 0000000..ea3e6d8
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/c/return_zero.c
@@ -0,0 +1,5 @@
+#include "return_zero.h"
+
+int return_zero() {
+    return 0;
+}
\ No newline at end of file
diff --git a/third_party/rules_rust/test/versioned_dylib/c/return_zero.h b/third_party/rules_rust/test/versioned_dylib/c/return_zero.h
new file mode 100644
index 0000000..4e7cb4a
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/c/return_zero.h
@@ -0,0 +1,6 @@
+#ifndef versioned_lib_h__
+#define versioned_lib_h__
+ 
+extern int return_zero();
+ 
+#endif  // versioned_lib_h__
\ No newline at end of file
diff --git a/third_party/rules_rust/test/versioned_dylib/src/main.rs b/third_party/rules_rust/test/versioned_dylib/src/main.rs
new file mode 100644
index 0000000..ee94707
--- /dev/null
+++ b/third_party/rules_rust/test/versioned_dylib/src/main.rs
@@ -0,0 +1,37 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+extern crate libc;
+
+extern "C" {
+    pub fn return_zero() -> libc::c_int;
+}
+
+fn main() {
+    let zero = unsafe { return_zero() };
+    println!("Got {} from our shared lib", zero);
+}
+
+#[cfg(test)]
+mod test {
+    extern "C" {
+        pub fn return_zero() -> libc::c_int;
+    }
+
+    #[test]
+    fn test_return_zero() {
+        assert_eq!(0, unsafe { return_zero() });
+        // If we make it past this call, it linked correctly, so the test passes.
+    }
+}
diff --git a/third_party/rules_rust/tools/BUILD.bazel b/third_party/rules_rust/tools/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/tools/BUILD.bazel
diff --git a/third_party/rules_rust/tools/allowlists/function_transition_allowlist/BUILD.bazel b/third_party/rules_rust/tools/allowlists/function_transition_allowlist/BUILD.bazel
new file mode 100644
index 0000000..9fdee4b
--- /dev/null
+++ b/third_party/rules_rust/tools/allowlists/function_transition_allowlist/BUILD.bazel
@@ -0,0 +1,4 @@
+package_group(
+    name = "function_transition_allowlist",
+    packages = ["//..."],
+)
diff --git a/third_party/rules_rust/tools/clippy/BUILD.bazel b/third_party/rules_rust/tools/clippy/BUILD.bazel
new file mode 100644
index 0000000..09e246f
--- /dev/null
+++ b/third_party/rules_rust/tools/clippy/BUILD.bazel
@@ -0,0 +1 @@
+exports_files(["clippy.toml"])
diff --git a/third_party/rules_rust/tools/clippy/clippy.toml b/third_party/rules_rust/tools/clippy/clippy.toml
new file mode 100644
index 0000000..7a4b169
--- /dev/null
+++ b/third_party/rules_rust/tools/clippy/clippy.toml
@@ -0,0 +1 @@
+# clippy options: https://rust-lang.github.io/rust-clippy/
diff --git a/third_party/rules_rust/tools/runfiles/BUILD.bazel b/third_party/rules_rust/tools/runfiles/BUILD.bazel
new file mode 100644
index 0000000..7a2eceb
--- /dev/null
+++ b/third_party/rules_rust/tools/runfiles/BUILD.bazel
@@ -0,0 +1,23 @@
+load(
+    "//rust:defs.bzl",
+    "rust_doc_test",
+    "rust_library",
+    "rust_test",
+)
+
+rust_library(
+    name = "runfiles",
+    srcs = ["runfiles.rs"],
+    visibility = ["//visibility:public"],
+)
+
+rust_test(
+    name = "runfiles_test",
+    crate = ":runfiles",
+    data = ["data/sample.txt"],
+)
+
+rust_doc_test(
+    name = "runfiles_doc_test",
+    crate = ":runfiles",
+)
diff --git a/third_party/rules_rust/tools/runfiles/data/sample.txt b/third_party/rules_rust/tools/runfiles/data/sample.txt
new file mode 100644
index 0000000..398ec97
--- /dev/null
+++ b/third_party/rules_rust/tools/runfiles/data/sample.txt
@@ -0,0 +1 @@
+Example Text!
\ No newline at end of file
diff --git a/third_party/rules_rust/tools/runfiles/runfiles.rs b/third_party/rules_rust/tools/runfiles/runfiles.rs
new file mode 100644
index 0000000..04f3366
--- /dev/null
+++ b/third_party/rules_rust/tools/runfiles/runfiles.rs
@@ -0,0 +1,250 @@
+//! Runfiles lookup library for Bazel-built Rust binaries and tests.
+//!
+//! USAGE:
+//!
+//! 1.  Depend on this runfiles library from your build rule:
+//!     ```python
+//!       rust_binary(
+//!           name = "my_binary",
+//!           ...
+//!           data = ["//path/to/my/data.txt"],
+//!           deps = ["@rules_rust//tools/runfiles"],
+//!       )
+//!     ```
+//!
+//! 2.  Import the runfiles library.
+//!     ```ignore
+//!     extern crate runfiles;
+//!
+//!     use runfiles::Runfiles;
+//!     ```
+//!
+//! 3.  Create a Runfiles object and use rlocation to look up runfile paths:
+//!     ```ignore -- This doesn't work under rust_doc_test because argv[0] is not what we expect.
+//!
+//!     use runfiles::Runfiles;
+//!
+//!     let r = Runfiles::create().unwrap();
+//!     let path = r.rlocation("my_workspace/path/to/my/data.txt");
+//!
+//!     let f = File::open(path).unwrap();
+//!     // ...
+//!     ```
+
+use std::collections::HashMap;
+use std::env;
+use std::ffi::OsString;
+use std::fs;
+use std::io;
+use std::path::Path;
+use std::path::PathBuf;
+
+#[derive(Debug)]
+enum Mode {
+    DirectoryBased(PathBuf),
+    ManifestBased(HashMap<PathBuf, PathBuf>),
+}
+
+#[derive(Debug)]
+pub struct Runfiles {
+    mode: Mode,
+}
+
+impl Runfiles {
+    /// Creates a manifest based Runfiles object when
+    /// RUNFILES_MANIFEST_ONLY environment variable is present,
+    /// or a directory based Runfiles object otherwise.
+    pub fn create() -> io::Result<Self> {
+        if is_manifest_only() {
+            Self::create_manifest_based()
+        } else {
+            Self::create_directory_based()
+        }
+    }
+
+    fn create_directory_based() -> io::Result<Self> {
+        Ok(Runfiles {
+            mode: Mode::DirectoryBased(find_runfiles_dir()?),
+        })
+    }
+
+    fn create_manifest_based() -> io::Result<Self> {
+        let manifest_path = find_manifest_path()?;
+        let manifest_content = std::fs::read_to_string(manifest_path)?;
+        let path_mapping = manifest_content
+            .lines()
+            .map(|line| {
+                let pair = line
+                    .split_once(' ')
+                    .expect("manifest file contained unexpected content");
+                (pair.0.into(), pair.1.into())
+            })
+            .collect::<HashMap<_, _>>();
+        Ok(Runfiles {
+            mode: Mode::ManifestBased(path_mapping),
+        })
+    }
+
+    /// Returns the runtime path of a runfile.
+    ///
+    /// Runfiles are data-dependencies of Bazel-built binaries and tests.
+    /// The returned path may not be valid. The caller should check the path's
+    /// validity and that the path exists.
+    pub fn rlocation(&self, path: impl AsRef<Path>) -> PathBuf {
+        let path = path.as_ref();
+        if path.is_absolute() {
+            return path.to_path_buf();
+        }
+        match &self.mode {
+            Mode::DirectoryBased(runfiles_dir) => runfiles_dir.join(path),
+            Mode::ManifestBased(path_mapping) => path_mapping
+                .get(path)
+                .unwrap_or_else(|| {
+                    panic!("Path {} not found among runfiles.", path.to_string_lossy())
+                })
+                .clone(),
+        }
+    }
+}
+
+/// Returns the .runfiles directory for the currently executing binary.
+pub fn find_runfiles_dir() -> io::Result<PathBuf> {
+    assert_ne!(
+        std::env::var_os("RUNFILES_MANIFEST_ONLY").unwrap_or_else(|| OsString::from("0")),
+        "1"
+    );
+
+    // If bazel told us about the runfiles dir, use that without looking further.
+    if let Some(test_srcdir) = std::env::var_os("TEST_SRCDIR").map(PathBuf::from) {
+        if test_srcdir.is_dir() {
+            return Ok(test_srcdir);
+        }
+    }
+
+    // Consume the first argument (argv[0])
+    let exec_path = std::env::args().next().expect("arg 0 was not set");
+
+    let mut binary_path = PathBuf::from(&exec_path);
+    loop {
+        // Check for our neighboring $binary.runfiles directory.
+        let mut runfiles_name = binary_path.file_name().unwrap().to_owned();
+        runfiles_name.push(".runfiles");
+
+        let runfiles_path = binary_path.with_file_name(&runfiles_name);
+        if runfiles_path.is_dir() {
+            return Ok(runfiles_path);
+        }
+
+        // Check if we're already under a *.runfiles directory.
+        {
+            // TODO: 1.28 adds Path::ancestors() which is a little simpler.
+            let mut next = binary_path.parent();
+            while let Some(ancestor) = next {
+                if ancestor
+                    .file_name()
+                    .map_or(false, |f| f.to_string_lossy().ends_with(".runfiles"))
+                {
+                    return Ok(ancestor.to_path_buf());
+                }
+                next = ancestor.parent();
+            }
+        }
+
+        if !fs::symlink_metadata(&binary_path)?.file_type().is_symlink() {
+            break;
+        }
+        // Follow symlinks and keep looking.
+        let link_target = binary_path.read_link()?;
+        binary_path = if link_target.is_absolute() {
+            link_target
+        } else {
+            let link_dir = binary_path.parent().unwrap();
+            env::current_dir()?.join(link_dir).join(link_target)
+        }
+    }
+
+    Err(make_io_error("failed to find .runfiles directory"))
+}
+
+fn make_io_error(msg: &str) -> io::Error {
+    io::Error::new(io::ErrorKind::Other, msg)
+}
+
+fn is_manifest_only() -> bool {
+    match std::env::var("RUNFILES_MANIFEST_ONLY") {
+        Ok(val) => val == "1",
+        Err(_) => false,
+    }
+}
+
+fn find_manifest_path() -> io::Result<PathBuf> {
+    assert_eq!(
+        std::env::var_os("RUNFILES_MANIFEST_ONLY").expect("RUNFILES_MANIFEST_ONLY was not set"),
+        OsString::from("1")
+    );
+    match std::env::var_os("RUNFILES_MANIFEST_FILE") {
+        Some(path) => Ok(path.into()),
+        None => Err(
+            make_io_error(
+                "RUNFILES_MANIFEST_ONLY was set to '1', but RUNFILES_MANIFEST_FILE was not set. Did Bazel change?"))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use std::fs::File;
+    use std::io::prelude::*;
+
+    #[test]
+    fn test_can_read_data_from_runfiles() {
+        // We want to run two test cases: one with the $TEST_SRCDIR environment variable set and one
+        // with it not set. Since environment variables are global state, we need to ensure the two
+        // test cases do not run concurrently. Rust runs tests in parallel and does not provide an
+        // easy way to synchronise them, so we run both test cases in the same #[test] function.
+
+        let test_srcdir = env::var_os("TEST_SRCDIR").expect("bazel did not provide TEST_SRCDIR");
+
+        // Test case 1: $TEST_SRCDIR is set.
+        {
+            let r = Runfiles::create().unwrap();
+
+            let mut f =
+                File::open(r.rlocation("rules_rust/tools/runfiles/data/sample.txt")).unwrap();
+
+            let mut buffer = String::new();
+            f.read_to_string(&mut buffer).unwrap();
+
+            assert_eq!("Example Text!", buffer);
+        }
+
+        // Test case 2: $TEST_SRCDIR is *not* set.
+        {
+            env::remove_var("TEST_SRCDIR");
+
+            let r = Runfiles::create().unwrap();
+
+            let mut f =
+                File::open(r.rlocation("rules_rust/tools/runfiles/data/sample.txt")).unwrap();
+
+            let mut buffer = String::new();
+            f.read_to_string(&mut buffer).unwrap();
+
+            assert_eq!("Example Text!", buffer);
+
+            env::set_var("TEST_SRCDIR", test_srcdir);
+        }
+    }
+
+    #[test]
+    fn test_manifest_based_can_read_data_from_runfiles() {
+        let mut path_mapping = HashMap::new();
+        path_mapping.insert("a/b".into(), "c/d".into());
+        let r = Runfiles {
+            mode: Mode::ManifestBased(path_mapping),
+        };
+
+        assert_eq!(r.rlocation("a/b"), PathBuf::from("c/d"));
+    }
+}
diff --git a/third_party/rules_rust/tools/rust_analyzer/BUILD.bazel b/third_party/rules_rust/tools/rust_analyzer/BUILD.bazel
new file mode 100644
index 0000000..d73ea63
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/BUILD.bazel
@@ -0,0 +1,56 @@
+load("//rust:defs.bzl", "rust_binary", "rust_clippy", "rust_library", "rust_test")
+load("//tools:tool_utils.bzl", "aspect_repository")
+
+rust_binary(
+    name = "gen_rust_project",
+    srcs = ["main.rs"],
+    edition = "2018",
+    rustc_env = {
+        "ASPECT_REPOSITORY": aspect_repository(),
+    },
+    visibility = ["//visibility:public"],
+    deps = [
+        ":gen_rust_project_lib",
+        "//tools/rust_analyzer/raze:anyhow",
+        "//tools/rust_analyzer/raze:env_logger",
+        "//tools/rust_analyzer/raze:log",
+        "//tools/rust_analyzer/raze:structopt",
+        "//util/label",
+    ],
+)
+
+rust_library(
+    name = "gen_rust_project_lib",
+    srcs = glob(
+        ["**/*.rs"],
+        exclude = ["main.rs"],
+    ),
+    data = [
+        "//rust/private:rust_analyzer_detect_sysroot",
+    ],
+    edition = "2018",
+    deps = [
+        "//tools/runfiles",
+        "//tools/rust_analyzer/raze:anyhow",
+        "//tools/rust_analyzer/raze:log",
+        "//tools/rust_analyzer/raze:serde",
+        "//tools/rust_analyzer/raze:serde_json",
+    ],
+)
+
+rust_test(
+    name = "gen_rust_project_lib_test",
+    crate = ":gen_rust_project_lib",
+    deps = [
+        "//tools/rust_analyzer/raze:itertools",
+    ],
+)
+
+rust_clippy(
+    name = "gen_rust_project_clippy",
+    testonly = True,
+    visibility = ["//visibility:private"],
+    deps = [
+        ":gen_rust_project",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/aquery.rs b/third_party/rules_rust/tools/rust_analyzer/aquery.rs
new file mode 100644
index 0000000..12164ab
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/aquery.rs
@@ -0,0 +1,590 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs::File;
+use std::option::Option;
+use std::path::Path;
+use std::path::PathBuf;
+use std::process::Command;
+
+use anyhow::Context;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct AqueryOutput {
+    artifacts: Vec<Artifact>,
+    actions: Vec<Action>,
+    #[serde(rename = "pathFragments")]
+    path_fragments: Vec<PathFragment>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Artifact {
+    id: u32,
+    #[serde(rename = "pathFragmentId")]
+    path_fragment_id: u32,
+}
+
+#[derive(Debug, Deserialize)]
+struct PathFragment {
+    id: u32,
+    label: String,
+    #[serde(rename = "parentId")]
+    parent_id: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Action {
+    #[serde(rename = "outputIds")]
+    output_ids: Vec<u32>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CrateSpec {
+    pub crate_id: String,
+    pub display_name: String,
+    pub edition: String,
+    pub root_module: String,
+    pub is_workspace_member: bool,
+    pub deps: BTreeSet<String>,
+    pub proc_macro_dylib_path: Option<String>,
+    pub source: Option<CrateSpecSource>,
+    pub cfg: Vec<String>,
+    pub env: BTreeMap<String, String>,
+    pub target: String,
+    pub crate_type: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CrateSpecSource {
+    pub exclude_dirs: Vec<String>,
+    pub include_dirs: Vec<String>,
+}
+
+pub fn get_crate_specs(
+    bazel: &Path,
+    workspace: &Path,
+    execution_root: &Path,
+    targets: &[String],
+    rules_rust_name: &str,
+) -> anyhow::Result<BTreeSet<CrateSpec>> {
+    log::debug!("Get crate specs with targets: {:?}", targets);
+    let target_pattern = targets
+        .iter()
+        .map(|t| format!("deps({})", t))
+        .collect::<Vec<_>>()
+        .join("+");
+
+    let aquery_output = Command::new(bazel)
+        .current_dir(workspace)
+        .arg("aquery")
+        .arg("--include_aspects")
+        .arg(format!(
+            "--aspects={}//rust:defs.bzl%rust_analyzer_aspect",
+            rules_rust_name
+        ))
+        .arg("--output_groups=rust_analyzer_crate_spec")
+        .arg(format!(
+            r#"outputs(".*[.]rust_analyzer_crate_spec",{})"#,
+            target_pattern
+        ))
+        .arg("--output=jsonproto")
+        .output()?;
+
+    let crate_spec_files =
+        parse_aquery_output_files(execution_root, &String::from_utf8(aquery_output.stdout)?)?;
+
+    let crate_specs = crate_spec_files
+        .into_iter()
+        .map(|file| {
+            let f = File::open(&file)
+                .with_context(|| format!("Failed to open file: {}", file.display()))?;
+            serde_json::from_reader(f)
+                .with_context(|| format!("Failed to deserialize file: {}", file.display()))
+        })
+        .collect::<anyhow::Result<Vec<CrateSpec>>>()?;
+
+    consolidate_crate_specs(crate_specs)
+}
+
+fn parse_aquery_output_files(
+    execution_root: &Path,
+    aquery_stdout: &str,
+) -> anyhow::Result<Vec<PathBuf>> {
+    let out: AqueryOutput = serde_json::from_str(aquery_stdout)?;
+
+    let artifacts = out
+        .artifacts
+        .iter()
+        .map(|a| (a.id, a))
+        .collect::<BTreeMap<_, _>>();
+    let path_fragments = out
+        .path_fragments
+        .iter()
+        .map(|pf| (pf.id, pf))
+        .collect::<BTreeMap<_, _>>();
+
+    let mut output_files: Vec<PathBuf> = Vec::new();
+    for action in out.actions {
+        for output_id in action.output_ids {
+            let artifact = artifacts
+                .get(&output_id)
+                .expect("internal consistency error in bazel output");
+            let path = path_from_fragments(artifact.path_fragment_id, &path_fragments)?;
+            let path = execution_root.join(path);
+            if path.exists() {
+                output_files.push(path);
+            } else {
+                log::warn!("Skipping missing crate_spec file: {:?}", path);
+            }
+        }
+    }
+
+    Ok(output_files)
+}
+
+fn path_from_fragments(
+    id: u32,
+    fragments: &BTreeMap<u32, &PathFragment>,
+) -> anyhow::Result<PathBuf> {
+    let path_fragment = fragments
+        .get(&id)
+        .expect("internal consistency error in bazel output");
+
+    let buf = match path_fragment.parent_id {
+        Some(parent_id) => path_from_fragments(parent_id, fragments)?
+            .join(PathBuf::from(&path_fragment.label.clone())),
+        None => PathBuf::from(&path_fragment.label.clone()),
+    };
+
+    Ok(buf)
+}
+
+/// Read all crate specs, deduplicating crates with the same ID. This happens when
+/// a rust_test depends on a rust_library, for example.
+fn consolidate_crate_specs(crate_specs: Vec<CrateSpec>) -> anyhow::Result<BTreeSet<CrateSpec>> {
+    let mut consolidated_specs: BTreeMap<String, CrateSpec> = BTreeMap::new();
+    for spec in crate_specs.into_iter() {
+        log::debug!("{:?}", spec);
+        if let Some(existing) = consolidated_specs.get_mut(&spec.crate_id) {
+            existing.deps.extend(spec.deps);
+
+            // display_name should match the library's crate name because Rust Analyzer
+            // seems to use display_name for matching crate entries in rust-project.json
+            // against symbols in source files. For more details, see
+            // https://github.com/bazelbuild/rules_rust/issues/1032
+            if spec.crate_type == "rlib" {
+                existing.display_name = spec.display_name;
+                existing.crate_type = "rlib".into();
+            }
+
+            // For proc-macro crates that exist within the workspace, there will be a
+            // generated crate-spec in both the fastbuild and opt-exec configuration.
+            // Prefer proc macro paths with an opt-exec component in the path.
+            if let Some(dylib_path) = spec.proc_macro_dylib_path.as_ref() {
+                const OPT_PATH_COMPONENT: &str = "-opt-exec-";
+                if dylib_path.contains(OPT_PATH_COMPONENT) {
+                    existing.proc_macro_dylib_path.replace(dylib_path.clone());
+                }
+            }
+        } else {
+            consolidated_specs.insert(spec.crate_id.clone(), spec);
+        }
+    }
+
+    Ok(consolidated_specs.into_values().collect())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use itertools::Itertools;
+
+    #[test]
+    fn consolidate_lib_then_test_specs() {
+        let crate_specs = vec![
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::from(["ID-lib_dep.rs".into()]),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-extra_test_dep.rs".into(),
+                display_name: "extra_test_dep".into(),
+                edition: "2018".into(),
+                root_module: "extra_test_dep.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-lib_dep.rs".into(),
+                display_name: "lib_dep".into(),
+                edition: "2018".into(),
+                root_module: "lib_dep.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib_test".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::from(["ID-extra_test_dep.rs".into()]),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "bin".into(),
+            },
+        ];
+
+        assert_eq!(
+            consolidate_crate_specs(crate_specs).unwrap(),
+            BTreeSet::from([
+                CrateSpec {
+                    crate_id: "ID-mylib.rs".into(),
+                    display_name: "mylib".into(),
+                    edition: "2018".into(),
+                    root_module: "mylib.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::from(["ID-lib_dep.rs".into(), "ID-extra_test_dep.rs".into()]),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-extra_test_dep.rs".into(),
+                    display_name: "extra_test_dep".into(),
+                    edition: "2018".into(),
+                    root_module: "extra_test_dep.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-lib_dep.rs".into(),
+                    display_name: "lib_dep".into(),
+                    edition: "2018".into(),
+                    root_module: "lib_dep.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+            ])
+        );
+    }
+
+    #[test]
+    fn consolidate_test_then_lib_specs() {
+        let crate_specs = vec![
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib_test".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::from(["ID-extra_test_dep.rs".into()]),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "bin".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::from(["ID-lib_dep.rs".into()]),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-extra_test_dep.rs".into(),
+                display_name: "extra_test_dep".into(),
+                edition: "2018".into(),
+                root_module: "extra_test_dep.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-lib_dep.rs".into(),
+                display_name: "lib_dep".into(),
+                edition: "2018".into(),
+                root_module: "lib_dep.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+        ];
+
+        assert_eq!(
+            consolidate_crate_specs(crate_specs).unwrap(),
+            BTreeSet::from([
+                CrateSpec {
+                    crate_id: "ID-mylib.rs".into(),
+                    display_name: "mylib".into(),
+                    edition: "2018".into(),
+                    root_module: "mylib.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::from(["ID-lib_dep.rs".into(), "ID-extra_test_dep.rs".into()]),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-extra_test_dep.rs".into(),
+                    display_name: "extra_test_dep".into(),
+                    edition: "2018".into(),
+                    root_module: "extra_test_dep.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-lib_dep.rs".into(),
+                    display_name: "lib_dep".into(),
+                    edition: "2018".into(),
+                    root_module: "lib_dep.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+            ])
+        );
+    }
+
+    #[test]
+    fn consolidate_lib_test_main_specs() {
+        // mylib.rs is a library but has tests and an entry point, and mylib2.rs
+        // depends on mylib.rs. The display_name of the library target mylib.rs
+        // should be "mylib" no matter what order the crate specs is in.
+        // Otherwise Rust Analyzer will not be able to resolve references to
+        // mylib in mylib2.rs.
+        let crate_specs = vec![
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib_test".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "bin".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-mylib.rs".into(),
+                display_name: "mylib_main".into(),
+                edition: "2018".into(),
+                root_module: "mylib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "bin".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-mylib2.rs".into(),
+                display_name: "mylib2".into(),
+                edition: "2018".into(),
+                root_module: "mylib2.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::from(["ID-mylib.rs".into()]),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            },
+        ];
+
+        for perm in crate_specs.into_iter().permutations(4) {
+            assert_eq!(
+                consolidate_crate_specs(perm).unwrap(),
+                BTreeSet::from([
+                    CrateSpec {
+                        crate_id: "ID-mylib.rs".into(),
+                        display_name: "mylib".into(),
+                        edition: "2018".into(),
+                        root_module: "mylib.rs".into(),
+                        is_workspace_member: true,
+                        deps: BTreeSet::from([]),
+                        proc_macro_dylib_path: None,
+                        source: None,
+                        cfg: vec!["test".into(), "debug_assertions".into()],
+                        env: BTreeMap::new(),
+                        target: "x86_64-unknown-linux-gnu".into(),
+                        crate_type: "rlib".into(),
+                    },
+                    CrateSpec {
+                        crate_id: "ID-mylib2.rs".into(),
+                        display_name: "mylib2".into(),
+                        edition: "2018".into(),
+                        root_module: "mylib2.rs".into(),
+                        is_workspace_member: true,
+                        deps: BTreeSet::from(["ID-mylib.rs".into()]),
+                        proc_macro_dylib_path: None,
+                        source: None,
+                        cfg: vec!["test".into(), "debug_assertions".into()],
+                        env: BTreeMap::new(),
+                        target: "x86_64-unknown-linux-gnu".into(),
+                        crate_type: "rlib".into(),
+                    },
+                ])
+            );
+        }
+    }
+
+    #[test]
+    fn consolidate_proc_macro_prefer_exec() {
+        // proc macro crates should prefer the -opt-exec- path which is always generated
+        // during builds where it is used, while the fastbuild version would only be built
+        // when explicitly building that target.
+        let crate_specs = vec![
+            CrateSpec {
+                crate_id: "ID-myproc_macro.rs".into(),
+                display_name: "myproc_macro".into(),
+                edition: "2018".into(),
+                root_module: "myproc_macro.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: Some(
+                    "bazel-out/k8-opt-exec-F005BA11/bin/myproc_macro/libmyproc_macro-12345.so"
+                        .into(),
+                ),
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "proc_macro".into(),
+            },
+            CrateSpec {
+                crate_id: "ID-myproc_macro.rs".into(),
+                display_name: "myproc_macro".into(),
+                edition: "2018".into(),
+                root_module: "myproc_macro.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: Some(
+                    "bazel-out/k8-fastbuild/bin/myproc_macro/libmyproc_macro-12345.so".into(),
+                ),
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "proc_macro".into(),
+            },
+        ];
+
+        for perm in crate_specs.into_iter().permutations(2) {
+            assert_eq!(
+                consolidate_crate_specs(perm).unwrap(),
+                BTreeSet::from([CrateSpec {
+                    crate_id: "ID-myproc_macro.rs".into(),
+                    display_name: "myproc_macro".into(),
+                    edition: "2018".into(),
+                    root_module: "myproc_macro.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: Some(
+                        "bazel-out/k8-opt-exec-F005BA11/bin/myproc_macro/libmyproc_macro-12345.so"
+                            .into()
+                    ),
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "proc_macro".into(),
+                },])
+            );
+        }
+    }
+}
diff --git a/third_party/rules_rust/tools/rust_analyzer/deps.bzl b/third_party/rules_rust/tools/rust_analyzer/deps.bzl
new file mode 100644
index 0000000..0d2b4a5
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/deps.bzl
@@ -0,0 +1,11 @@
+"""
+The dependencies for running the gen_rust_project binary.
+"""
+
+load("//tools/rust_analyzer/raze:crates.bzl", "rules_rust_tools_rust_analyzer_fetch_remote_crates")
+
+def rust_analyzer_deps():
+    rules_rust_tools_rust_analyzer_fetch_remote_crates()
+
+# For legacy support
+gen_rust_project_dependencies = rust_analyzer_deps
diff --git a/third_party/rules_rust/tools/rust_analyzer/lib.rs b/third_party/rules_rust/tools/rust_analyzer/lib.rs
new file mode 100644
index 0000000..68db7e0
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/lib.rs
@@ -0,0 +1,79 @@
+use std::path::Path;
+use std::process::Command;
+
+use anyhow::anyhow;
+use runfiles::Runfiles;
+
+mod aquery;
+mod rust_project;
+
+const SYSROOT_SRC_FILE_RUNFILES_PREFIX: &str = "rules_rust";
+
+pub fn generate_crate_info(
+    bazel: impl AsRef<Path>,
+    workspace: impl AsRef<Path>,
+    rules_rust: impl AsRef<str>,
+    targets: &[String],
+) -> anyhow::Result<()> {
+    log::debug!("Building rust_analyzer_crate_spec files for {:?}", targets);
+
+    let output = Command::new(bazel.as_ref())
+        .current_dir(workspace.as_ref())
+        .arg("build")
+        .arg(format!(
+            "--aspects={}//rust:defs.bzl%rust_analyzer_aspect",
+            rules_rust.as_ref()
+        ))
+        .arg("--output_groups=rust_analyzer_crate_spec")
+        .args(targets)
+        .output()?;
+
+    if !output.status.success() {
+        return Err(anyhow!(
+            "bazel build failed:({})\n{}",
+            output.status,
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+
+    Ok(())
+}
+
+pub fn write_rust_project(
+    bazel: impl AsRef<Path>,
+    workspace: impl AsRef<Path>,
+    rules_rust_name: &impl AsRef<str>,
+    targets: &[String],
+    execution_root: impl AsRef<Path>,
+    rust_project_path: impl AsRef<Path>,
+) -> anyhow::Result<()> {
+    let crate_specs = aquery::get_crate_specs(
+        bazel.as_ref(),
+        workspace.as_ref(),
+        execution_root.as_ref(),
+        targets,
+        rules_rust_name.as_ref(),
+    )?;
+
+    let workspace_name = match rules_rust_name.as_ref().trim_start_matches('@') {
+        "" => SYSROOT_SRC_FILE_RUNFILES_PREFIX,
+        s => s,
+    };
+    let sysroot_path = format!(
+        "{}/rust/private/rust_analyzer_detect_sysroot.rust_analyzer_sysroot_src",
+        workspace_name
+    );
+    let r = Runfiles::create()?;
+    let path = r.rlocation(sysroot_path);
+    let sysroot_src = std::fs::read_to_string(&path)?;
+
+    let rust_project = rust_project::generate_rust_project(&sysroot_src, &crate_specs)?;
+
+    rust_project::write_rust_project(
+        rust_project_path.as_ref(),
+        execution_root.as_ref(),
+        &rust_project,
+    )?;
+
+    Ok(())
+}
diff --git a/third_party/rules_rust/tools/rust_analyzer/main.rs b/third_party/rules_rust/tools/rust_analyzer/main.rs
new file mode 100644
index 0000000..2bad0e9
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/main.rs
@@ -0,0 +1,120 @@
+use std::collections::HashMap;
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+use anyhow::anyhow;
+use gen_rust_project_lib::generate_crate_info;
+use gen_rust_project_lib::write_rust_project;
+use structopt::StructOpt;
+
+// TODO(david): This shells out to an expected rule in the workspace root //:rust_analyzer that the user must define.
+// It would be more convenient if it could automatically discover all the rust code in the workspace if this target
+// does not exist.
+fn main() -> anyhow::Result<()> {
+    env_logger::init();
+
+    let config = parse_config()?;
+
+    let workspace_root = config
+        .workspace
+        .as_ref()
+        .expect("failed to find workspace root, set with --workspace");
+
+    let execution_root = config
+        .execution_root
+        .as_ref()
+        .expect("failed to find execution root, is --execution-root set correctly?");
+
+    let rules_rust_name = env!("ASPECT_REPOSITORY");
+
+    // Generate the crate specs.
+    generate_crate_info(
+        &config.bazel,
+        &workspace_root,
+        &rules_rust_name,
+        &config.targets,
+    )?;
+
+    // Use the generated files to write rust-project.json.
+    write_rust_project(
+        &config.bazel,
+        &workspace_root,
+        &rules_rust_name,
+        &config.targets,
+        &execution_root,
+        &workspace_root.join("rust-project.json"),
+    )?;
+
+    Ok(())
+}
+
+// Parse the configuration flags and supplement with bazel info as needed.
+fn parse_config() -> anyhow::Result<Config> {
+    let mut config = Config::from_args();
+
+    // Ensure we know the workspace. If we are under `bazel run`, the
+    // BUILD_WORKSPACE_DIR environment variable will be present.
+    if config.workspace.is_none() {
+        if let Some(ws_dir) = env::var_os("BUILD_WORKSPACE_DIRECTORY") {
+            config.workspace = Some(PathBuf::from(ws_dir));
+        }
+    }
+
+    if config.workspace.is_some() && config.execution_root.is_some() {
+        return Ok(config);
+    }
+
+    // We need some info from `bazel info`. Fetch it now.
+    let mut bazel_info_command = Command::new(&config.bazel);
+    bazel_info_command.arg("info");
+    if let Some(workspace) = &config.workspace {
+        bazel_info_command.current_dir(workspace);
+    }
+
+    // Execute bazel info.
+    let output = bazel_info_command.output()?;
+    if !output.status.success() {
+        return Err(anyhow!(
+            "Failed to run `bazel info` ({:?}): {}",
+            output.status,
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+
+    // Extract the output.
+    let output = String::from_utf8_lossy(output.stdout.as_slice());
+    let bazel_info = output
+        .trim()
+        .split('\n')
+        .map(|line| line.split_at(line.find(':').expect("missing `:` in bazel info output")))
+        .map(|(k, v)| (k, (&v[1..]).trim()))
+        .collect::<HashMap<_, _>>();
+
+    if config.workspace.is_none() {
+        config.workspace = bazel_info.get("workspace").map(Into::into);
+    }
+    if config.execution_root.is_none() {
+        config.execution_root = bazel_info.get("execution_root").map(Into::into);
+    }
+
+    Ok(config)
+}
+
+#[derive(Debug, StructOpt)]
+struct Config {
+    // If not specified, uses the result of `bazel info workspace`.
+    #[structopt(long)]
+    workspace: Option<PathBuf>,
+
+    // If not specified, uses the result of `bazel info execution_root`.
+    #[structopt(long)]
+    execution_root: Option<PathBuf>,
+
+    #[structopt(long, default_value = "bazel")]
+    bazel: PathBuf,
+
+    // Space separated list of target patterns that comes after all other args.
+    #[structopt(default_value = "@//...")]
+    targets: Vec<String>,
+}
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/BUILD.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/BUILD.bazel
new file mode 100644
index 0000000..a494da4
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/BUILD.bazel
@@ -0,0 +1,84 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "anyhow",
+    actual = "@rules_rust_tools_rust_analyzer__anyhow__1_0_45//:anyhow",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "env_logger",
+    actual = "@rules_rust_tools_rust_analyzer__env_logger__0_9_0//:env_logger",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "itertools",
+    actual = "@rules_rust_tools_rust_analyzer__itertools__0_10_1//:itertools",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "log",
+    actual = "@rules_rust_tools_rust_analyzer__log__0_4_14//:log",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "serde",
+    actual = "@rules_rust_tools_rust_analyzer__serde__1_0_130//:serde",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "serde_json",
+    actual = "@rules_rust_tools_rust_analyzer__serde_json__1_0_69//:serde_json",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "structopt",
+    actual = "@rules_rust_tools_rust_analyzer__structopt__0_3_25//:structopt",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.raze.lock b/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.raze.lock
new file mode 100644
index 0000000..d78e906
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.raze.lock
@@ -0,0 +1,377 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "2.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
+[[package]]
+name = "compile_with_bazel"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "env_logger",
+ "itertools",
+ "log",
+ "serde",
+ "serde_json",
+ "structopt",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "env_logger"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "itertools"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "ryu"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+
+[[package]]
+name = "serde"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e466864e431129c7e0d3476b92f20458e5879919a0596c6472738d9fa2d342f8"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "structopt"
+version = "0.3.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40b9788f4202aa75c240ecc9c15c65185e6a39ccdeb0fd5d008b98825464c87c"
+dependencies = [
+ "clap",
+ "lazy_static",
+ "structopt-derive",
+]
+
+[[package]]
+name = "structopt-derive"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.toml b/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.toml
new file mode 100644
index 0000000..4a9b0ee
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "compile_with_bazel"
+version = "0.0.0"
+edition="2018"
+
+[lib]
+path = "fake_lib.rs"
+
+[dependencies]
+anyhow = "1.0"
+log = "0.4"
+env_logger = "0.9"
+serde = { version = "1.0", features = ["derive"] } 
+serde_json = "1.0"
+structopt = "0.3"
+
+[dev-dependencies]
+itertools = "0.10"
+
+[package.metadata.raze]
+genmode = "Remote"
+workspace_path = "//tools/rust_analyzer/raze"
+gen_workspace_prefix = "rules_rust_tools_rust_analyzer"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "."
+default_gen_buildrs = true
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/crates.bzl b/third_party/rules_rust/tools/rust_analyzer/raze/crates.bzl
new file mode 100644
index 0000000..336972e
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/crates.bzl
@@ -0,0 +1,442 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def rules_rust_tools_rust_analyzer_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__aho_corasick__0_7_18",
+        url = "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+        type = "tar.gz",
+        sha256 = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f",
+        strip_prefix = "aho-corasick-0.7.18",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.aho-corasick-0.7.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__ansi_term__0_11_0",
+        url = "https://crates.io/api/v1/crates/ansi_term/0.11.0/download",
+        type = "tar.gz",
+        sha256 = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b",
+        strip_prefix = "ansi_term-0.11.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.ansi_term-0.11.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__anyhow__1_0_45",
+        url = "https://crates.io/api/v1/crates/anyhow/1.0.45/download",
+        type = "tar.gz",
+        sha256 = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7",
+        strip_prefix = "anyhow-1.0.45",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.anyhow-1.0.45.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__atty__0_2_14",
+        url = "https://crates.io/api/v1/crates/atty/0.2.14/download",
+        type = "tar.gz",
+        sha256 = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8",
+        strip_prefix = "atty-0.2.14",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.atty-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__bitflags__1_3_2",
+        url = "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+        type = "tar.gz",
+        sha256 = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",
+        strip_prefix = "bitflags-1.3.2",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.bitflags-1.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__cfg_if__1_0_0",
+        url = "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__clap__2_33_3",
+        url = "https://crates.io/api/v1/crates/clap/2.33.3/download",
+        type = "tar.gz",
+        sha256 = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002",
+        strip_prefix = "clap-2.33.3",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.clap-2.33.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__either__1_6_1",
+        url = "https://crates.io/api/v1/crates/either/1.6.1/download",
+        type = "tar.gz",
+        sha256 = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457",
+        strip_prefix = "either-1.6.1",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.either-1.6.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__env_logger__0_9_0",
+        url = "https://crates.io/api/v1/crates/env_logger/0.9.0/download",
+        type = "tar.gz",
+        sha256 = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3",
+        strip_prefix = "env_logger-0.9.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.env_logger-0.9.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__heck__0_3_3",
+        url = "https://crates.io/api/v1/crates/heck/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c",
+        strip_prefix = "heck-0.3.3",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.heck-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__hermit_abi__0_1_19",
+        url = "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+        type = "tar.gz",
+        sha256 = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33",
+        strip_prefix = "hermit-abi-0.1.19",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.hermit-abi-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__humantime__2_1_0",
+        url = "https://crates.io/api/v1/crates/humantime/2.1.0/download",
+        type = "tar.gz",
+        sha256 = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4",
+        strip_prefix = "humantime-2.1.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.humantime-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__itertools__0_10_1",
+        url = "https://crates.io/api/v1/crates/itertools/0.10.1/download",
+        type = "tar.gz",
+        sha256 = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf",
+        strip_prefix = "itertools-0.10.1",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.itertools-0.10.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__itoa__0_4_8",
+        url = "https://crates.io/api/v1/crates/itoa/0.4.8/download",
+        type = "tar.gz",
+        sha256 = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4",
+        strip_prefix = "itoa-0.4.8",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.itoa-0.4.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__libc__0_2_107",
+        url = "https://crates.io/api/v1/crates/libc/0.2.107/download",
+        type = "tar.gz",
+        sha256 = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219",
+        strip_prefix = "libc-0.2.107",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.libc-0.2.107.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__log__0_4_14",
+        url = "https://crates.io/api/v1/crates/log/0.4.14/download",
+        type = "tar.gz",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        strip_prefix = "log-0.4.14",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__memchr__2_4_1",
+        url = "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+        type = "tar.gz",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__proc_macro_error__1_0_4",
+        url = "https://crates.io/api/v1/crates/proc-macro-error/1.0.4/download",
+        type = "tar.gz",
+        sha256 = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c",
+        strip_prefix = "proc-macro-error-1.0.4",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.proc-macro-error-1.0.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__proc_macro_error_attr__1_0_4",
+        url = "https://crates.io/api/v1/crates/proc-macro-error-attr/1.0.4/download",
+        type = "tar.gz",
+        sha256 = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869",
+        strip_prefix = "proc-macro-error-attr-1.0.4",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.proc-macro-error-attr-1.0.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__proc_macro2__1_0_32",
+        url = "https://crates.io/api/v1/crates/proc-macro2/1.0.32/download",
+        type = "tar.gz",
+        sha256 = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43",
+        strip_prefix = "proc-macro2-1.0.32",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.proc-macro2-1.0.32.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__quote__1_0_10",
+        url = "https://crates.io/api/v1/crates/quote/1.0.10/download",
+        type = "tar.gz",
+        sha256 = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05",
+        strip_prefix = "quote-1.0.10",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.quote-1.0.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__regex__1_5_4",
+        url = "https://crates.io/api/v1/crates/regex/1.5.4/download",
+        type = "tar.gz",
+        sha256 = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461",
+        strip_prefix = "regex-1.5.4",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.regex-1.5.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__regex_syntax__0_6_25",
+        url = "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+        type = "tar.gz",
+        sha256 = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b",
+        strip_prefix = "regex-syntax-0.6.25",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.regex-syntax-0.6.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__ryu__1_0_5",
+        url = "https://crates.io/api/v1/crates/ryu/1.0.5/download",
+        type = "tar.gz",
+        sha256 = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e",
+        strip_prefix = "ryu-1.0.5",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.ryu-1.0.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__serde__1_0_130",
+        url = "https://crates.io/api/v1/crates/serde/1.0.130/download",
+        type = "tar.gz",
+        sha256 = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913",
+        strip_prefix = "serde-1.0.130",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.serde-1.0.130.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__serde_derive__1_0_130",
+        url = "https://crates.io/api/v1/crates/serde_derive/1.0.130/download",
+        type = "tar.gz",
+        sha256 = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b",
+        strip_prefix = "serde_derive-1.0.130",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.serde_derive-1.0.130.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__serde_json__1_0_69",
+        url = "https://crates.io/api/v1/crates/serde_json/1.0.69/download",
+        type = "tar.gz",
+        sha256 = "e466864e431129c7e0d3476b92f20458e5879919a0596c6472738d9fa2d342f8",
+        strip_prefix = "serde_json-1.0.69",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.serde_json-1.0.69.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__strsim__0_8_0",
+        url = "https://crates.io/api/v1/crates/strsim/0.8.0/download",
+        type = "tar.gz",
+        sha256 = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a",
+        strip_prefix = "strsim-0.8.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.strsim-0.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__structopt__0_3_25",
+        url = "https://crates.io/api/v1/crates/structopt/0.3.25/download",
+        type = "tar.gz",
+        sha256 = "40b9788f4202aa75c240ecc9c15c65185e6a39ccdeb0fd5d008b98825464c87c",
+        strip_prefix = "structopt-0.3.25",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.structopt-0.3.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__structopt_derive__0_4_18",
+        url = "https://crates.io/api/v1/crates/structopt-derive/0.4.18/download",
+        type = "tar.gz",
+        sha256 = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0",
+        strip_prefix = "structopt-derive-0.4.18",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.structopt-derive-0.4.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__syn__1_0_81",
+        url = "https://crates.io/api/v1/crates/syn/1.0.81/download",
+        type = "tar.gz",
+        sha256 = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966",
+        strip_prefix = "syn-1.0.81",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.syn-1.0.81.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__termcolor__1_1_2",
+        url = "https://crates.io/api/v1/crates/termcolor/1.1.2/download",
+        type = "tar.gz",
+        sha256 = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4",
+        strip_prefix = "termcolor-1.1.2",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.termcolor-1.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__textwrap__0_11_0",
+        url = "https://crates.io/api/v1/crates/textwrap/0.11.0/download",
+        type = "tar.gz",
+        sha256 = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060",
+        strip_prefix = "textwrap-0.11.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.textwrap-0.11.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__unicode_segmentation__1_8_0",
+        url = "https://crates.io/api/v1/crates/unicode-segmentation/1.8.0/download",
+        type = "tar.gz",
+        sha256 = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b",
+        strip_prefix = "unicode-segmentation-1.8.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.unicode-segmentation-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__unicode_width__0_1_9",
+        url = "https://crates.io/api/v1/crates/unicode-width/0.1.9/download",
+        type = "tar.gz",
+        sha256 = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973",
+        strip_prefix = "unicode-width-0.1.9",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.unicode-width-0.1.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__unicode_xid__0_2_2",
+        url = "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+        type = "tar.gz",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__vec_map__0_8_2",
+        url = "https://crates.io/api/v1/crates/vec_map/0.8.2/download",
+        type = "tar.gz",
+        sha256 = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191",
+        strip_prefix = "vec_map-0.8.2",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.vec_map-0.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__version_check__0_9_3",
+        url = "https://crates.io/api/v1/crates/version_check/0.9.3/download",
+        type = "tar.gz",
+        sha256 = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe",
+        strip_prefix = "version_check-0.9.3",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.version_check-0.9.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__winapi__0_3_9",
+        url = "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+        type = "tar.gz",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__winapi_i686_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__winapi_util__0_1_5",
+        url = "https://crates.io/api/v1/crates/winapi-util/0.1.5/download",
+        type = "tar.gz",
+        sha256 = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178",
+        strip_prefix = "winapi-util-0.1.5",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.winapi-util-0.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_tools_rust_analyzer__winapi_x86_64_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("//tools/rust_analyzer/raze/remote:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.aho-corasick-0.7.18.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.aho-corasick-0.7.18.bazel
new file mode 100644
index 0000000..d0d1788
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.aho-corasick-0.7.18.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "aho_corasick",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__memchr__2_4_1//:memchr",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ansi_term-0.11.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ansi_term-0.11.0.bazel
new file mode 100644
index 0000000..e742b36
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ansi_term-0.11.0.bazel
@@ -0,0 +1,66 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "colours" with type "example" omitted
+
+rust_library(
+    name = "ansi_term",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.11.0",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(target_os = "windows")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_tools_rust_analyzer__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.anyhow-1.0.45.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.anyhow-1.0.45.bazel
new file mode 100644
index 0000000..737d7df
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.anyhow-1.0.45.bazel
@@ -0,0 +1,113 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "anyhow_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.45",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "anyhow",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.45",
+    # buildifier: leave-alone
+    deps = [
+        ":anyhow_build_script",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test_autotrait" with type "test" omitted
+
+# Unsupported target "test_backtrace" with type "test" omitted
+
+# Unsupported target "test_boxed" with type "test" omitted
+
+# Unsupported target "test_chain" with type "test" omitted
+
+# Unsupported target "test_context" with type "test" omitted
+
+# Unsupported target "test_convert" with type "test" omitted
+
+# Unsupported target "test_downcast" with type "test" omitted
+
+# Unsupported target "test_ffi" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
+
+# Unsupported target "test_macros" with type "test" omitted
+
+# Unsupported target "test_repr" with type "test" omitted
+
+# Unsupported target "test_source" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.atty-0.2.14.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.atty-0.2.14.bazel
new file mode 100644
index 0000000..c8b5efa
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.atty-0.2.14.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "atty" with type "example" omitted
+
+rust_library(
+    name = "atty",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.14",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_tools_rust_analyzer__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_tools_rust_analyzer__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bitflags-1.3.2.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bitflags-1.3.2.bazel
new file mode 100644
index 0000000..417aee7
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.bitflags-1.3.2.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.3.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "basic" with type "test" omitted
+
+# Unsupported target "compile" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..84595a6
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.clap-2.33.3.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.clap-2.33.3.bazel
new file mode 100644
index 0000000..0ecdf7a
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.clap-2.33.3.bazel
@@ -0,0 +1,93 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "clap",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "ansi_term",
+        "atty",
+        "color",
+        "default",
+        "strsim",
+        "suggestions",
+        "vec_map",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.33.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__atty__0_2_14//:atty",
+        "@rules_rust_tools_rust_analyzer__bitflags__1_3_2//:bitflags",
+        "@rules_rust_tools_rust_analyzer__strsim__0_8_0//:strsim",
+        "@rules_rust_tools_rust_analyzer__textwrap__0_11_0//:textwrap",
+        "@rules_rust_tools_rust_analyzer__unicode_width__0_1_9//:unicode_width",
+        "@rules_rust_tools_rust_analyzer__vec_map__0_8_2//:vec_map",
+    ] + selects.with_or({
+        # cfg(not(windows))
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_tools_rust_analyzer__ansi_term__0_11_0//:ansi_term",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.either-1.6.1.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.either-1.6.1.bazel
new file mode 100644
index 0000000..0af0135
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.either-1.6.1.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "either",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.6.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.env_logger-0.9.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.env_logger-0.9.0.bazel
new file mode 100644
index 0000000..4d35482
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.env_logger-0.9.0.bazel
@@ -0,0 +1,71 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "env_logger",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "atty",
+        "default",
+        "humantime",
+        "regex",
+        "termcolor",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__atty__0_2_14//:atty",
+        "@rules_rust_tools_rust_analyzer__humantime__2_1_0//:humantime",
+        "@rules_rust_tools_rust_analyzer__log__0_4_14//:log",
+        "@rules_rust_tools_rust_analyzer__regex__1_5_4//:regex",
+        "@rules_rust_tools_rust_analyzer__termcolor__1_1_2//:termcolor",
+    ],
+)
+
+# Unsupported target "init-twice-retains-filter" with type "test" omitted
+
+# Unsupported target "log-in-log" with type "test" omitted
+
+# Unsupported target "log_tls_dtors" with type "test" omitted
+
+# Unsupported target "regexp_filter" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.heck-0.3.3.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.heck-0.3.3.bazel
new file mode 100644
index 0000000..7aac083
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.heck-0.3.3.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "heck",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__unicode_segmentation__1_8_0//:unicode_segmentation",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.hermit-abi-0.1.19.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.hermit-abi-0.1.19.bazel
new file mode 100644
index 0000000..99cba1b
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.hermit-abi-0.1.19.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.19",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__libc__0_2_107//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.humantime-2.1.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.humantime-2.1.0.bazel
new file mode 100644
index 0000000..9905a0d
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.humantime-2.1.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "datetime_format" with type "bench" omitted
+
+# Unsupported target "datetime_parse" with type "bench" omitted
+
+rust_library(
+    name = "humantime",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itertools-0.10.1.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itertools-0.10.1.bazel
new file mode 100644
index 0000000..20935bf
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itertools-0.10.1.bazel
@@ -0,0 +1,99 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench1" with type "bench" omitted
+
+# Unsupported target "combinations" with type "bench" omitted
+
+# Unsupported target "combinations_with_replacement" with type "bench" omitted
+
+# Unsupported target "fold_specialization" with type "bench" omitted
+
+# Unsupported target "powerset" with type "bench" omitted
+
+# Unsupported target "tree_fold1" with type "bench" omitted
+
+# Unsupported target "tuple_combinations" with type "bench" omitted
+
+# Unsupported target "tuples" with type "bench" omitted
+
+# Unsupported target "iris" with type "example" omitted
+
+rust_library(
+    name = "itertools",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "use_alloc",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__either__1_6_1//:either",
+    ],
+)
+
+# Unsupported target "adaptors_no_collect" with type "test" omitted
+
+# Unsupported target "flatten_ok" with type "test" omitted
+
+# Unsupported target "fold_specialization" with type "test" omitted
+
+# Unsupported target "macros_hygiene" with type "test" omitted
+
+# Unsupported target "merge_join" with type "test" omitted
+
+# Unsupported target "peeking_take_while" with type "test" omitted
+
+# Unsupported target "quick" with type "test" omitted
+
+# Unsupported target "specializations" with type "test" omitted
+
+# Unsupported target "test_core" with type "test" omitted
+
+# Unsupported target "test_std" with type "test" omitted
+
+# Unsupported target "tuples" with type "test" omitted
+
+# Unsupported target "zip" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itoa-0.4.8.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itoa-0.4.8.bazel
new file mode 100644
index 0000000..27868c7
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.itoa-0.4.8.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "itoa",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..ba88ed7
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.libc-0.2.107.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.libc-0.2.107.bazel
new file mode 100644
index 0000000..bfb4b82
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.libc-0.2.107.bazel
@@ -0,0 +1,85 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libc_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.107",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.107",
+    # buildifier: leave-alone
+    deps = [
+        ":libc_build_script",
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.log-0.4.14.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..79cad4d
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.log-0.4.14.bazel
@@ -0,0 +1,92 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "log_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "value" with type "bench" omitted
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    # buildifier: leave-alone
+    deps = [
+        ":log_build_script",
+        "@rules_rust_tools_rust_analyzer__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
+
+# Unsupported target "macros" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..2016ce4
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,87 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "memchr_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "memchr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.1",
+    # buildifier: leave-alone
+    deps = [
+        ":memchr_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-1.0.4.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-1.0.4.bazel
new file mode 100644
index 0000000..c6c622c
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-1.0.4.bazel
@@ -0,0 +1,102 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "proc_macro_error_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "syn",
+        "syn-error",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.4",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_tools_rust_analyzer__version_check__0_9_3//:version_check",
+    ],
+)
+
+rust_library(
+    name = "proc_macro_error",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "syn",
+        "syn-error",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_tools_rust_analyzer__proc_macro_error_attr__1_0_4//:proc_macro_error_attr",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.4",
+    # buildifier: leave-alone
+    deps = [
+        ":proc_macro_error_build_script",
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_tools_rust_analyzer__quote__1_0_10//:quote",
+        "@rules_rust_tools_rust_analyzer__syn__1_0_81//:syn",
+    ],
+)
+
+# Unsupported target "macro-errors" with type "test" omitted
+
+# Unsupported target "ok" with type "test" omitted
+
+# Unsupported target "runtime-errors" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-attr-1.0.4.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-attr-1.0.4.bazel
new file mode 100644
index 0000000..ba807a8
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro-error-attr-1.0.4.bazel
@@ -0,0 +1,86 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "proc_macro_error_attr_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.4",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_tools_rust_analyzer__version_check__0_9_3//:version_check",
+    ],
+)
+
+rust_proc_macro(
+    name = "proc_macro_error_attr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.4",
+    # buildifier: leave-alone
+    deps = [
+        ":proc_macro_error_attr_build_script",
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_tools_rust_analyzer__quote__1_0_10//:quote",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro2-1.0.32.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro2-1.0.32.bazel
new file mode 100644
index 0000000..9252841
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.proc-macro2-1.0.32.bazel
@@ -0,0 +1,98 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "proc_macro2_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.32",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.32",
+    # buildifier: leave-alone
+    deps = [
+        ":proc_macro2_build_script",
+        "@rules_rust_tools_rust_analyzer__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "comments" with type "test" omitted
+
+# Unsupported target "features" with type "test" omitted
+
+# Unsupported target "marker" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.quote-1.0.10.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.quote-1.0.10.bazel
new file mode 100644
index 0000000..77f5236
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.quote-1.0.10.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "quote",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.10",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-1.5.4.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-1.5.4.bazel
new file mode 100644
index 0000000..8ba41a8
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-1.5.4.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "shootout-regex-dna" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-bytes" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-cheat" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-replace" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single-cheat" with type "example" omitted
+
+rust_library(
+    name = "regex",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "aho-corasick",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__aho_corasick__0_7_18//:aho_corasick",
+        "@rules_rust_tools_rust_analyzer__memchr__2_4_1//:memchr",
+        "@rules_rust_tools_rust_analyzer__regex_syntax__0_6_25//:regex_syntax",
+    ],
+)
+
+# Unsupported target "backtrack" with type "test" omitted
+
+# Unsupported target "backtrack-bytes" with type "test" omitted
+
+# Unsupported target "backtrack-utf8bytes" with type "test" omitted
+
+# Unsupported target "crates-regex" with type "test" omitted
+
+# Unsupported target "default" with type "test" omitted
+
+# Unsupported target "default-bytes" with type "test" omitted
+
+# Unsupported target "nfa" with type "test" omitted
+
+# Unsupported target "nfa-bytes" with type "test" omitted
+
+# Unsupported target "nfa-utf8bytes" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-syntax-0.6.25.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-syntax-0.6.25.bazel
new file mode 100644
index 0000000..d4e0b56
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.regex-syntax-0.6.25.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "regex_syntax",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.25",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ryu-1.0.5.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ryu-1.0.5.bazel
new file mode 100644
index 0000000..d4df380
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.ryu-1.0.5.bazel
@@ -0,0 +1,101 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR BSL-1.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "ryu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "bench" with type "bench" omitted
+
+# Unsupported target "upstream_benchmark" with type "example" omitted
+
+rust_library(
+    name = "ryu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.5",
+    # buildifier: leave-alone
+    deps = [
+        ":ryu_build_script",
+    ],
+)
+
+# Unsupported target "common_test" with type "test" omitted
+
+# Unsupported target "d2s_table_test" with type "test" omitted
+
+# Unsupported target "d2s_test" with type "test" omitted
+
+# Unsupported target "exhaustive" with type "test" omitted
+
+# Unsupported target "f2s_test" with type "test" omitted
+
+# Unsupported target "s2d_test" with type "test" omitted
+
+# Unsupported target "s2f_test" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde-1.0.130.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde-1.0.130.bazel
new file mode 100644
index 0000000..7b5cb8c
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde-1.0.130.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "derive",
+        "serde_derive",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "serde",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "derive",
+        "serde_derive",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    proc_macro_deps = [
+        "@rules_rust_tools_rust_analyzer__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_derive-1.0.130.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_derive-1.0.130.bazel
new file mode 100644
index 0000000..2d84e1d
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_derive-1.0.130.bazel
@@ -0,0 +1,88 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_derive_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_proc_macro(
+    name = "serde_derive",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_derive_build_script",
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_tools_rust_analyzer__quote__1_0_10//:quote",
+        "@rules_rust_tools_rust_analyzer__syn__1_0_81//:syn",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_json-1.0.69.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_json-1.0.69.bazel
new file mode 100644
index 0000000..2f4105f
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.serde_json-1.0.69.bazel
@@ -0,0 +1,90 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_json_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "serde_json",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_json_build_script",
+        "@rules_rust_tools_rust_analyzer__itoa__0_4_8//:itoa",
+        "@rules_rust_tools_rust_analyzer__ryu__1_0_5//:ryu",
+        "@rules_rust_tools_rust_analyzer__serde__1_0_130//:serde",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.strsim-0.8.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.strsim-0.8.0.bazel
new file mode 100644
index 0000000..a4df21a
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.strsim-0.8.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+rust_library(
+    name = "strsim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "lib" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-0.3.25.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-0.3.25.bazel
new file mode 100644
index 0000000..24b86f7
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-0.3.25.bazel
@@ -0,0 +1,155 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "after_help" with type "example" omitted
+
+# Unsupported target "at_least_two" with type "example" omitted
+
+# Unsupported target "basic" with type "example" omitted
+
+# Unsupported target "deny_missing_docs" with type "example" omitted
+
+# Unsupported target "doc_comments" with type "example" omitted
+
+# Unsupported target "enum_in_args" with type "example" omitted
+
+# Unsupported target "enum_in_args_with_strum" with type "example" omitted
+
+# Unsupported target "enum_tuple" with type "example" omitted
+
+# Unsupported target "env" with type "example" omitted
+
+# Unsupported target "example" with type "example" omitted
+
+# Unsupported target "flatten" with type "example" omitted
+
+# Unsupported target "gen_completions" with type "example" omitted
+
+# Unsupported target "git" with type "example" omitted
+
+# Unsupported target "group" with type "example" omitted
+
+# Unsupported target "keyvalue" with type "example" omitted
+
+# Unsupported target "negative_flag" with type "example" omitted
+
+# Unsupported target "no_version" with type "example" omitted
+
+# Unsupported target "rename_all" with type "example" omitted
+
+# Unsupported target "required_if" with type "example" omitted
+
+# Unsupported target "skip" with type "example" omitted
+
+# Unsupported target "subcommand_aliases" with type "example" omitted
+
+# Unsupported target "true_or_false" with type "example" omitted
+
+rust_library(
+    name = "structopt",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_tools_rust_analyzer__structopt_derive__0_4_18//:structopt_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.25",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__clap__2_33_3//:clap",
+        "@rules_rust_tools_rust_analyzer__lazy_static__1_4_0//:lazy_static",
+    ],
+)
+
+# Unsupported target "argument_naming" with type "test" omitted
+
+# Unsupported target "arguments" with type "test" omitted
+
+# Unsupported target "author_version_about" with type "test" omitted
+
+# Unsupported target "custom-string-parsers" with type "test" omitted
+
+# Unsupported target "default_value" with type "test" omitted
+
+# Unsupported target "deny-warnings" with type "test" omitted
+
+# Unsupported target "doc-comments-help" with type "test" omitted
+
+# Unsupported target "explicit_name_no_renaming" with type "test" omitted
+
+# Unsupported target "flags" with type "test" omitted
+
+# Unsupported target "flatten" with type "test" omitted
+
+# Unsupported target "generics" with type "test" omitted
+
+# Unsupported target "issues" with type "test" omitted
+
+# Unsupported target "macro-errors" with type "test" omitted
+
+# Unsupported target "nested-subcommands" with type "test" omitted
+
+# Unsupported target "non_literal_attributes" with type "test" omitted
+
+# Unsupported target "options" with type "test" omitted
+
+# Unsupported target "privacy" with type "test" omitted
+
+# Unsupported target "raw_bool_literal" with type "test" omitted
+
+# Unsupported target "raw_idents" with type "test" omitted
+
+# Unsupported target "regressions" with type "test" omitted
+
+# Unsupported target "rename_all_env" with type "test" omitted
+
+# Unsupported target "skip" with type "test" omitted
+
+# Unsupported target "special_types" with type "test" omitted
+
+# Unsupported target "subcommands" with type "test" omitted
+
+# Unsupported target "utils" with type "test" omitted
+
+# Unsupported target "we_need_syn_full" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-derive-0.4.18.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-derive-0.4.18.bazel
new file mode 100644
index 0000000..8c8dfd8
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.structopt-derive-0.4.18.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_proc_macro(
+    name = "structopt_derive",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__heck__0_3_3//:heck",
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_tools_rust_analyzer__proc_macro_error__1_0_4//:proc_macro_error",
+        "@rules_rust_tools_rust_analyzer__quote__1_0_10//:quote",
+        "@rules_rust_tools_rust_analyzer__syn__1_0_81//:syn",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.syn-1.0.81.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.syn-1.0.81.bazel
new file mode 100644
index 0000000..efd5cfe
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.syn-1.0.81.bazel
@@ -0,0 +1,158 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "syn_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.81",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "file" with type "bench" omitted
+
+# Unsupported target "rust" with type "bench" omitted
+
+rust_library(
+    name = "syn",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.81",
+    # buildifier: leave-alone
+    deps = [
+        ":syn_build_script",
+        "@rules_rust_tools_rust_analyzer__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_tools_rust_analyzer__quote__1_0_10//:quote",
+        "@rules_rust_tools_rust_analyzer__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "test_asyncness" with type "test" omitted
+
+# Unsupported target "test_attribute" with type "test" omitted
+
+# Unsupported target "test_derive_input" with type "test" omitted
+
+# Unsupported target "test_expr" with type "test" omitted
+
+# Unsupported target "test_generics" with type "test" omitted
+
+# Unsupported target "test_grouping" with type "test" omitted
+
+# Unsupported target "test_ident" with type "test" omitted
+
+# Unsupported target "test_item" with type "test" omitted
+
+# Unsupported target "test_iterators" with type "test" omitted
+
+# Unsupported target "test_lit" with type "test" omitted
+
+# Unsupported target "test_meta" with type "test" omitted
+
+# Unsupported target "test_parse_buffer" with type "test" omitted
+
+# Unsupported target "test_parse_stream" with type "test" omitted
+
+# Unsupported target "test_pat" with type "test" omitted
+
+# Unsupported target "test_path" with type "test" omitted
+
+# Unsupported target "test_precedence" with type "test" omitted
+
+# Unsupported target "test_receiver" with type "test" omitted
+
+# Unsupported target "test_round_trip" with type "test" omitted
+
+# Unsupported target "test_shebang" with type "test" omitted
+
+# Unsupported target "test_should_parse" with type "test" omitted
+
+# Unsupported target "test_size" with type "test" omitted
+
+# Unsupported target "test_stmt" with type "test" omitted
+
+# Unsupported target "test_token_trees" with type "test" omitted
+
+# Unsupported target "test_ty" with type "test" omitted
+
+# Unsupported target "test_visibility" with type "test" omitted
+
+# Unsupported target "zzz_stable" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.termcolor-1.1.2.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.termcolor-1.1.2.bazel
new file mode 100644
index 0000000..7605e0c
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.termcolor-1.1.2.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "termcolor",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.2",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_tools_rust_analyzer__winapi_util__0_1_5//:winapi_util",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.textwrap-0.11.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.textwrap-0.11.0.bazel
new file mode 100644
index 0000000..38a4138
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.textwrap-0.11.0.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "linear" with type "bench" omitted
+
+# Unsupported target "layout" with type "example" omitted
+
+# Unsupported target "termwidth" with type "example" omitted
+
+rust_library(
+    name = "textwrap",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.11.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_tools_rust_analyzer__unicode_width__0_1_9//:unicode_width",
+    ],
+)
+
+# Unsupported target "version-numbers" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel
new file mode 100644
index 0000000..126a432
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "graphemes" with type "bench" omitted
+
+# Unsupported target "unicode_words" with type "bench" omitted
+
+# Unsupported target "word_bounds" with type "bench" omitted
+
+rust_library(
+    name = "unicode_segmentation",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.8.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-width-0.1.9.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-width-0.1.9.bazel
new file mode 100644
index 0000000..1b1b356
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-width-0.1.9.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "unicode_width",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.9",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..9b7936d
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "xid" with type "bench" omitted
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "exhaustive_tests" with type "test" omitted
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.vec_map-0.8.2.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.vec_map-0.8.2.bazel
new file mode 100644
index 0000000..a9ca9b9
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.vec_map-0.8.2.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "vec_map",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.version_check-0.9.3.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.version_check-0.9.3.bazel
new file mode 100644
index 0000000..2d24b1f
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.version_check-0.9.3.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "version_check",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..89fc3a8
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,105 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "minwinbase",
+        "minwindef",
+        "processenv",
+        "std",
+        "winbase",
+        "wincon",
+        "winerror",
+        "winnt",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "minwinbase",
+        "minwindef",
+        "processenv",
+        "std",
+        "winbase",
+        "wincon",
+        "winerror",
+        "winnt",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..0920950
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_i686_pc_windows_gnu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_i686_pc_windows_gnu_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-util-0.1.5.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-util-0.1.5.bazel
new file mode 100644
index 0000000..d72f51f
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-util-0.1.5.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "winapi_util",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.5",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_tools_rust_analyzer__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..b6b2804
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//tools/rust_analyzer/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_x86_64_pc_windows_gnu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_x86_64_pc_windows_gnu_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rust_analyzer/rust_project.rs b/third_party/rules_rust/tools/rust_analyzer/rust_project.rs
new file mode 100644
index 0000000..0cc9378
--- /dev/null
+++ b/third_party/rules_rust/tools/rust_analyzer/rust_project.rs
@@ -0,0 +1,311 @@
+//! Library for generating rust_project.json files from a `Vec<CrateSpec>`
+//! See official documentation of file format at https://rust-analyzer.github.io/manual.html
+
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::io::ErrorKind;
+use std::path::Path;
+
+use anyhow::anyhow;
+use serde::Serialize;
+
+use crate::aquery::CrateSpec;
+
+/// A `rust-project.json` workspace representation. See
+/// [rust-analyzer documentation][rd] for a thorough description of this interface.
+/// [rd]: https://rust-analyzer.github.io/manual.html#non-cargo-based-projects
+#[derive(Debug, Serialize)]
+pub struct RustProject {
+    /// Path to the directory with *source code* of
+    /// sysroot crates.
+    sysroot_src: Option<String>,
+
+    /// The set of crates comprising the current
+    /// project. Must include all transitive
+    /// dependencies as well as sysroot crate (libstd,
+    /// libcore and such).
+    crates: Vec<Crate>,
+}
+
+/// A `rust-project.json` crate representation. See
+/// [rust-analyzer documentation][rd] for a thorough description of this interface.
+/// [rd]: https://rust-analyzer.github.io/manual.html#non-cargo-based-projects
+#[derive(Debug, Serialize)]
+pub struct Crate {
+    /// A name used in the package's project declaration
+    #[serde(skip_serializing_if = "Option::is_none")]
+    display_name: Option<String>,
+
+    /// Path to the root module of the crate.
+    root_module: String,
+
+    /// Edition of the crate.
+    edition: String,
+
+    /// Dependencies
+    deps: Vec<Dependency>,
+
+    /// Should this crate be treated as a member of current "workspace".
+    #[serde(skip_serializing_if = "Option::is_none")]
+    is_workspace_member: Option<bool>,
+
+    /// Optionally specify the (super)set of `.rs` files comprising this crate.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    source: Option<Source>,
+
+    /// The set of cfgs activated for a given crate, like
+    /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
+    cfg: Vec<String>,
+
+    /// Target triple for this Crate.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    target: Option<String>,
+
+    /// Environment variables, used for the `env!` macro
+    #[serde(skip_serializing_if = "Option::is_none")]
+    env: Option<BTreeMap<String, String>>,
+
+    /// Whether the crate is a proc-macro crate.
+    is_proc_macro: bool,
+
+    /// For proc-macro crates, path to compiled proc-macro (.so file).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    proc_macro_dylib_path: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Source {
+    include_dirs: Vec<String>,
+    exclude_dirs: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Dependency {
+    /// Index of a crate in the `crates` array.
+    #[serde(rename = "crate")]
+    crate_index: usize,
+
+    /// The display name of the crate.
+    name: String,
+}
+
+pub fn generate_rust_project(
+    sysroot_src: &str,
+    crates: &BTreeSet<CrateSpec>,
+) -> anyhow::Result<RustProject> {
+    let mut project = RustProject {
+        sysroot_src: Some(sysroot_src.into()),
+        crates: Vec::new(),
+    };
+
+    let mut unmerged_crates: Vec<&CrateSpec> = crates.iter().collect();
+    let mut skipped_crates: Vec<&CrateSpec> = Vec::new();
+    let mut merged_crates_index: HashMap<String, usize> = HashMap::new();
+
+    while !unmerged_crates.is_empty() {
+        for c in unmerged_crates.iter() {
+            if c.deps
+                .iter()
+                .any(|dep| !merged_crates_index.contains_key(dep))
+            {
+                log::trace!(
+                    "Skipped crate {} because missing deps: {:?}",
+                    &c.crate_id,
+                    c.deps
+                        .iter()
+                        .filter(|dep| !merged_crates_index.contains_key(*dep))
+                        .cloned()
+                        .collect::<Vec<_>>()
+                );
+                skipped_crates.push(c);
+            } else {
+                log::trace!("Merging crate {}", &c.crate_id);
+                merged_crates_index.insert(c.crate_id.clone(), project.crates.len());
+                project.crates.push(Crate {
+                    display_name: Some(c.display_name.clone()),
+                    root_module: c.root_module.clone(),
+                    edition: c.edition.clone(),
+                    deps: c
+                        .deps
+                        .iter()
+                        .map(|dep| {
+                            let crate_index = *merged_crates_index
+                                .get(dep)
+                                .expect("failed to find dependency on second lookup");
+                            let dep_crate = &project.crates[crate_index as usize];
+                            Dependency {
+                                crate_index,
+                                name: dep_crate
+                                    .display_name
+                                    .as_ref()
+                                    .expect("all crates should have display_name")
+                                    .clone(),
+                            }
+                        })
+                        .collect(),
+                    is_workspace_member: Some(c.is_workspace_member),
+                    source: c.source.as_ref().map(|s| Source {
+                        exclude_dirs: s.exclude_dirs.clone(),
+                        include_dirs: s.include_dirs.clone(),
+                    }),
+                    cfg: c.cfg.clone(),
+                    target: Some(c.target.clone()),
+                    env: Some(c.env.clone()),
+                    is_proc_macro: c.proc_macro_dylib_path.is_some(),
+                    proc_macro_dylib_path: c.proc_macro_dylib_path.clone(),
+                });
+            }
+        }
+
+        // This should not happen, but if it does exit to prevent infinite loop.
+        if unmerged_crates.len() == skipped_crates.len() {
+            log::debug!(
+                "Did not make progress on {} unmerged crates. Crates: {:?}",
+                skipped_crates.len(),
+                skipped_crates
+            );
+            return Err(anyhow!(
+                "Failed to make progress on building crate dependency graph"
+            ));
+        }
+        std::mem::swap(&mut unmerged_crates, &mut skipped_crates);
+        skipped_crates.clear();
+    }
+
+    Ok(project)
+}
+
+pub fn write_rust_project(
+    rust_project_path: &Path,
+    execution_root: &Path,
+    rust_project: &RustProject,
+) -> anyhow::Result<()> {
+    let execution_root = execution_root
+        .to_str()
+        .ok_or_else(|| anyhow!("execution_root is not valid UTF-8"))?;
+
+    // Try to remove the existing rust-project.json. It's OK if the file doesn't exist.
+    match std::fs::remove_file(rust_project_path) {
+        Ok(_) => {}
+        Err(err) if err.kind() == ErrorKind::NotFound => {}
+        Err(err) => {
+            return Err(anyhow!(
+                "Unexpected error removing old rust-project.json: {}",
+                err
+            ))
+        }
+    }
+
+    // Render the `rust-project.json` file and replace the exec root
+    // placeholders with the path to the local exec root.
+    let rust_project_content =
+        serde_json::to_string(rust_project)?.replace("__EXEC_ROOT__", execution_root);
+
+    // Write the new rust-project.json file.
+    std::fs::write(rust_project_path, rust_project_content)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::collections::BTreeSet;
+
+    use crate::aquery::CrateSpec;
+
+    /// A simple example with a single crate and no dependencies.
+    #[test]
+    fn generate_rust_project_single() {
+        let project = generate_rust_project(
+            "sysroot",
+            &BTreeSet::from([CrateSpec {
+                crate_id: "ID-example".into(),
+                display_name: "example".into(),
+                edition: "2018".into(),
+                root_module: "example/lib.rs".into(),
+                is_workspace_member: true,
+                deps: BTreeSet::new(),
+                proc_macro_dylib_path: None,
+                source: None,
+                cfg: vec!["test".into(), "debug_assertions".into()],
+                env: BTreeMap::new(),
+                target: "x86_64-unknown-linux-gnu".into(),
+                crate_type: "rlib".into(),
+            }]),
+        )
+        .expect("expect success");
+
+        assert_eq!(project.crates.len(), 1);
+        let c = &project.crates[0];
+        assert_eq!(c.display_name, Some("example".into()));
+        assert_eq!(c.root_module, "example/lib.rs");
+        assert_eq!(c.deps.len(), 0);
+    }
+
+    /// An example with a one crate having two dependencies.
+    #[test]
+    fn generate_rust_project_with_deps() {
+        let project = generate_rust_project(
+            "sysroot",
+            &BTreeSet::from([
+                CrateSpec {
+                    crate_id: "ID-example".into(),
+                    display_name: "example".into(),
+                    edition: "2018".into(),
+                    root_module: "example/lib.rs".into(),
+                    is_workspace_member: true,
+                    deps: BTreeSet::from(["ID-dep_a".into(), "ID-dep_b".into()]),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-dep_a".into(),
+                    display_name: "dep_a".into(),
+                    edition: "2018".into(),
+                    root_module: "dep_a/lib.rs".into(),
+                    is_workspace_member: false,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+                CrateSpec {
+                    crate_id: "ID-dep_b".into(),
+                    display_name: "dep_b".into(),
+                    edition: "2018".into(),
+                    root_module: "dep_b/lib.rs".into(),
+                    is_workspace_member: false,
+                    deps: BTreeSet::new(),
+                    proc_macro_dylib_path: None,
+                    source: None,
+                    cfg: vec!["test".into(), "debug_assertions".into()],
+                    env: BTreeMap::new(),
+                    target: "x86_64-unknown-linux-gnu".into(),
+                    crate_type: "rlib".into(),
+                },
+            ]),
+        )
+        .expect("expect success");
+
+        assert_eq!(project.crates.len(), 3);
+        // Both dep_a and dep_b should be one of the first two crates.
+        assert!(
+            Some("dep_a".into()) == project.crates[0].display_name
+                || Some("dep_a".into()) == project.crates[1].display_name
+        );
+        assert!(
+            Some("dep_b".into()) == project.crates[0].display_name
+                || Some("dep_b".into()) == project.crates[1].display_name
+        );
+        let c = &project.crates[2];
+        assert_eq!(c.display_name, Some("example".into()));
+    }
+}
diff --git a/third_party/rules_rust/tools/rustdoc/BUILD.bazel b/third_party/rules_rust/tools/rustdoc/BUILD.bazel
new file mode 100644
index 0000000..f941759
--- /dev/null
+++ b/third_party/rules_rust/tools/rustdoc/BUILD.bazel
@@ -0,0 +1,12 @@
+load("//rust:defs.bzl", "rust_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "rustdoc_test_writer",
+    srcs = ["rustdoc_test_writer.rs"],
+    edition = "2018",
+    deps = [
+        "//tools/runfiles",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rustdoc/rustdoc_test_writer.rs b/third_party/rules_rust/tools/rustdoc/rustdoc_test_writer.rs
new file mode 100644
index 0000000..6803e8b
--- /dev/null
+++ b/third_party/rules_rust/tools/rustdoc/rustdoc_test_writer.rs
@@ -0,0 +1,205 @@
+//! A utility for writing scripts for use as test executables intended to match the
+//! subcommands of Bazel build actions so `rustdoc --test`, which builds and tests
+//! code in a single call, can be run as a test target in a hermetic manner.
+
+use std::cmp::Reverse;
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug)]
+struct Options {
+    /// A list of environment variable keys to parse from the build action env.
+    env_keys: BTreeSet<String>,
+
+    /// A list of substrings to strip from [Options::action_argv].
+    strip_substrings: Vec<String>,
+
+    /// The path where the script should be written.
+    output: PathBuf,
+
+    /// The `argv` of the configured rustdoc build action.
+    action_argv: Vec<String>,
+}
+
+/// Parse command line arguments
+fn parse_args() -> Options {
+    let args: Vec<String> = env::args().into_iter().collect();
+    let (writer_args, action_args) = {
+        let split = args
+            .iter()
+            .position(|arg| arg == "--")
+            .expect("Unable to find split identifier `--`");
+
+        // Converting each set into a vector makes them easier to parse in
+        // the absence of nightly features
+        let (writer, action) = args.split_at(split);
+        (writer.to_vec(), action.to_vec())
+    };
+
+    // Remove the leading `--` which is expected to be the first
+    // item in `action_args`
+    debug_assert_eq!(action_args[0], "--");
+    let action_argv = action_args[1..].to_vec();
+
+    let output = writer_args
+        .iter()
+        .find(|arg| arg.starts_with("--output="))
+        .and_then(|arg| arg.splitn(2, '=').last())
+        .map(PathBuf::from)
+        .expect("Missing `--output` argument");
+
+    let (strip_substring_args, writer_args): (Vec<String>, Vec<String>) = writer_args
+        .into_iter()
+        .partition(|arg| arg.starts_with("--strip_substring="));
+
+    let mut strip_substrings: Vec<String> = strip_substring_args
+        .into_iter()
+        .map(|arg| {
+            arg.splitn(2, '=')
+                .last()
+                .expect("--strip_substring arguments must have assignments using `=`")
+                .to_owned()
+        })
+        .collect();
+
+    // Strip substrings should always be in reverse order of the length of each
+    // string so when filtering we know that the longer strings are checked
+    // first in order to avoid cases where shorter strings might match longer ones.
+    strip_substrings.sort_by_key(|b| Reverse(b.len()));
+    strip_substrings.dedup();
+
+    let env_keys = writer_args
+        .into_iter()
+        .filter(|arg| arg.starts_with("--action_env="))
+        .map(|arg| {
+            arg.splitn(2, '=')
+                .last()
+                .expect("--env arguments must have assignments using `=`")
+                .to_owned()
+        })
+        .collect();
+
+    Options {
+        env_keys,
+        strip_substrings,
+        output,
+        action_argv,
+    }
+}
+
+/// Write a unix compatible test runner
+fn write_test_runner_unix(
+    path: &Path,
+    env: &BTreeMap<String, String>,
+    argv: &[String],
+    strip_substrings: &[String],
+) {
+    let mut content = vec![
+        "#!/usr/bin/env bash".to_owned(),
+        "".to_owned(),
+        "exec env - \\".to_owned(),
+    ];
+
+    content.extend(env.iter().map(|(key, val)| format!("{}='{}' \\", key, val)));
+
+    let argv_str = argv
+        .iter()
+        // Remove any substrings found in the argument
+        .map(|arg| {
+            let mut stripped_arg = arg.to_owned();
+            strip_substrings
+                .iter()
+                .for_each(|substring| stripped_arg = stripped_arg.replace(substring, ""));
+            stripped_arg
+        })
+        .map(|arg| format!("'{}'", arg))
+        .collect::<Vec<String>>()
+        .join(" ");
+
+    content.extend(vec![argv_str, "".to_owned()]);
+
+    fs::write(path, content.join("\n")).expect("Failed to write test runner");
+}
+
+/// Write a windows compatible test runner
+fn write_test_runner_windows(
+    path: &Path,
+    env: &BTreeMap<String, String>,
+    argv: &[String],
+    strip_substrings: &[String],
+) {
+    let env_str = env
+        .iter()
+        .map(|(key, val)| format!("$env:{}='{}'", key, val))
+        .collect::<Vec<String>>()
+        .join(" ; ");
+
+    let argv_str = argv
+        .iter()
+        // Remove any substrings found in the argument
+        .map(|arg| {
+            let mut stripped_arg = arg.to_owned();
+            strip_substrings
+                .iter()
+                .for_each(|substring| stripped_arg = stripped_arg.replace(substring, ""));
+            stripped_arg
+        })
+        .map(|arg| format!("'{}'", arg))
+        .collect::<Vec<String>>()
+        .join(" ");
+
+    let content = vec![
+        "@ECHO OFF".to_owned(),
+        "".to_owned(),
+        format!("powershell.exe -c \"{} ; & {}\"", env_str, argv_str),
+        "".to_owned(),
+    ];
+
+    fs::write(path, content.join("\n")).expect("Failed to write test runner");
+}
+
+#[cfg(target_family = "unix")]
+fn set_executable(path: &Path) {
+    use std::os::unix::prelude::PermissionsExt;
+
+    let mut perm = fs::metadata(path)
+        .expect("Failed to get test runner metadata")
+        .permissions();
+
+    perm.set_mode(0o755);
+    fs::set_permissions(path, perm).expect("Failed to set permissions on test runner");
+}
+
+#[cfg(target_family = "windows")]
+fn set_executable(_path: &Path) {
+    // Windows determines whether or not a file is executable via the PATHEXT
+    // environment variable. This function is a no-op for this platform.
+}
+
+fn write_test_runner(
+    path: &Path,
+    env: &BTreeMap<String, String>,
+    argv: &[String],
+    strip_substrings: &[String],
+) {
+    if cfg!(target_family = "unix") {
+        write_test_runner_unix(path, env, argv, strip_substrings);
+    } else if cfg!(target_family = "windows") {
+        write_test_runner_windows(path, env, argv, strip_substrings);
+    }
+
+    set_executable(path);
+}
+
+fn main() {
+    let opt = parse_args();
+
+    let env: BTreeMap<String, String> = env::vars()
+        .into_iter()
+        .filter(|(key, _)| opt.env_keys.iter().any(|k| k == key))
+        .collect();
+
+    write_test_runner(&opt.output, &env, &opt.action_argv, &opt.strip_substrings);
+}
diff --git a/third_party/rules_rust/tools/rustfmt/BUILD.bazel b/third_party/rules_rust/tools/rustfmt/BUILD.bazel
new file mode 100644
index 0000000..1456eb1
--- /dev/null
+++ b/third_party/rules_rust/tools/rustfmt/BUILD.bazel
@@ -0,0 +1,65 @@
+load("//rust:defs.bzl", "rust_binary", "rust_clippy", "rust_library")
+load("//tools:tool_utils.bzl", "aspect_repository")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "rustfmt.toml",
+    "rustfmt_utils.bzl",
+])
+
+rust_library(
+    name = "rustfmt_lib",
+    srcs = glob(
+        ["srcs/**/*.rs"],
+        exclude = ["srcs/**/*main.rs"],
+    ),
+    data = [
+        "//:rustfmt.toml",
+        "//rust/toolchain:current_exec_rustfmt_files",
+    ],
+    edition = "2018",
+    rustc_env = {
+        "RUSTFMT": "$(rootpath //rust/toolchain:current_exec_rustfmt_files)",
+        "RUSTFMT_CONFIG": "$(rootpath //:rustfmt.toml)",
+    },
+)
+
+rust_binary(
+    name = "rustfmt",
+    srcs = [
+        "srcs/main.rs",
+    ],
+    data = [
+        "//:rustfmt.toml",
+    ],
+    edition = "2018",
+    rustc_env = {
+        "ASPECT_REPOSITORY": aspect_repository(),
+    },
+    deps = [
+        ":rustfmt_lib",
+        "//util/label",
+    ],
+)
+
+rust_binary(
+    name = "rustfmt_test",
+    srcs = [
+        "srcs/test_main.rs",
+    ],
+    edition = "2018",
+    deps = [
+        ":rustfmt_lib",
+        "//tools/runfiles",
+    ],
+)
+
+rust_clippy(
+    name = "rustfmt_clippy",
+    testonly = True,
+    visibility = ["//visibility:private"],
+    deps = [
+        ":rustfmt",
+    ],
+)
diff --git a/third_party/rules_rust/tools/rustfmt/rustfmt.toml b/third_party/rules_rust/tools/rustfmt/rustfmt.toml
new file mode 100644
index 0000000..44bdbf2
--- /dev/null
+++ b/third_party/rules_rust/tools/rustfmt/rustfmt.toml
@@ -0,0 +1 @@
+# rustfmt options: https://rust-lang.github.io/rustfmt/
diff --git a/third_party/rules_rust/tools/rustfmt/srcs/lib.rs b/third_party/rules_rust/tools/rustfmt/srcs/lib.rs
new file mode 100644
index 0000000..ad2e86a
--- /dev/null
+++ b/third_party/rules_rust/tools/rustfmt/srcs/lib.rs
@@ -0,0 +1,74 @@
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// The expected extension of rustfmt manifest files generated by `rustfmt_aspect`.
+pub const RUSTFMT_MANIFEST_EXTENSION: &str = "rustfmt";
+
+/// Generate an absolute path to a file without resolving symlinks
+fn absolutify_existing<T: AsRef<Path>>(path: &T) -> std::io::Result<PathBuf> {
+    let absolute_path = if path.as_ref().is_absolute() {
+        path.as_ref().to_owned()
+    } else {
+        std::env::current_dir()
+            .expect("Failed to get working directory")
+            .join(path)
+    };
+    std::fs::metadata(&absolute_path).map(|_| absolute_path)
+}
+
+/// A struct containing details used for executing rustfmt.
+#[derive(Debug)]
+pub struct RustfmtConfig {
+    /// The rustfmt binary from the currently active toolchain
+    pub rustfmt: PathBuf,
+
+    /// The rustfmt config file containing rustfmt settings.
+    /// https://rust-lang.github.io/rustfmt/
+    pub config: PathBuf,
+}
+
+/// Parse command line arguments and environment variables to
+/// produce config data for running rustfmt.
+pub fn parse_rustfmt_config() -> RustfmtConfig {
+    RustfmtConfig {
+        rustfmt: absolutify_existing(&env!("RUSTFMT")).expect("Unable to find rustfmt binary"),
+        config: absolutify_existing(&env!("RUSTFMT_CONFIG"))
+            .expect("Unable to find rustfmt config file"),
+    }
+}
+
+/// A struct of target specific information for use in running `rustfmt`.
+#[derive(Debug)]
+pub struct RustfmtManifest {
+    /// The Rust edition of the Bazel target
+    pub edition: String,
+
+    /// A list of all (non-generated) source files for formatting.
+    pub sources: Vec<String>,
+}
+
+/// Parse rustfmt flags from a manifest generated by builds using `rustfmt_aspect`.
+pub fn parse_rustfmt_manifest(manifest: &Path) -> RustfmtManifest {
+    let content = fs::read_to_string(manifest)
+        .unwrap_or_else(|_| panic!("Failed to read rustfmt manifest: {}", manifest.display()));
+
+    let mut lines: Vec<String> = content
+        .split('\n')
+        .into_iter()
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_owned())
+        .collect();
+
+    let edition = lines
+        .pop()
+        .expect("There should always be at least 1 line in the manifest");
+    edition
+        .parse::<i32>()
+        .expect("The edition should be a numeric value. eg `2018`.");
+
+    RustfmtManifest {
+        edition,
+        sources: lines,
+    }
+}
diff --git a/third_party/rules_rust/tools/rustfmt/srcs/main.rs b/third_party/rules_rust/tools/rustfmt/srcs/main.rs
new file mode 100644
index 0000000..4e4419f
--- /dev/null
+++ b/third_party/rules_rust/tools/rustfmt/srcs/main.rs
@@ -0,0 +1,185 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::str;
+
+fn main() {
+    // Gather all command line and environment settings
+    let options = parse_args();
+
+    // Gather a list of all formattable targets
+    let targets = query_rustfmt_targets(&options);
+
+    // Run rustfmt on these targets
+    apply_rustfmt(&options, &targets);
+}
+
+/// Perform a `bazel` query to determine a list of Bazel targets which are to be formatted.
+fn query_rustfmt_targets(options: &Config) -> Vec<String> {
+    // Determine what packages to query
+    let scope = match options.packages.is_empty() {
+        true => "//...:all".to_owned(),
+        false => {
+            // Check to see if all the provided packages are actually targets
+            let is_all_targets = options
+                .packages
+                .iter()
+                .all(|pkg| match label::analyze(pkg) {
+                    Ok(tgt) => tgt.name != "all",
+                    Err(_) => false,
+                });
+
+            // Early return if a list of targets and not packages were provided
+            if is_all_targets {
+                return options.packages.clone();
+            }
+
+            options.packages.join(" + ")
+        }
+    };
+
+    let query_args = vec![
+        "query".to_owned(),
+        format!(
+            r#"kind('{types}', {scope}) except attr(tags, 'norustfmt', kind('{types}', {scope}))"#,
+            types = "^rust_",
+            scope = scope
+        ),
+    ];
+
+    let child = Command::new(&options.bazel)
+        .current_dir(&options.workspace)
+        .args(query_args)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .expect("Failed to spawn bazel query command");
+
+    let output = child
+        .wait_with_output()
+        .expect("Failed to wait on spawned command");
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    str::from_utf8(&output.stdout)
+        .expect("Invalid stream from command")
+        .split('\n')
+        .filter(|line| !line.is_empty())
+        .map(|line| line.to_string())
+        .collect()
+}
+
+/// Build a list of Bazel targets using the `rustfmt_aspect` to produce the
+/// arguments to use when formatting the sources of those targets.
+fn generate_rustfmt_target_manifests(options: &Config, targets: &[String]) {
+    let build_args = vec![
+        "build".to_owned(),
+        format!(
+            "--aspects={}//rust:defs.bzl%rustfmt_aspect",
+            env!("ASPECT_REPOSITORY")
+        ),
+        "--output_groups=rustfmt_manifest".to_owned(),
+    ];
+
+    let child = Command::new(&options.bazel)
+        .current_dir(&options.workspace)
+        .args(build_args)
+        .args(targets)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .expect("Failed to spawn command");
+
+    let output = child
+        .wait_with_output()
+        .expect("Failed to wait on spawned command");
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+}
+
+/// Run rustfmt on a set of Bazel targets
+fn apply_rustfmt(options: &Config, targets: &[String]) {
+    // Ensure the targets are first built and a manifest containing `rustfmt`
+    // arguments are generated before formatting source files.
+    generate_rustfmt_target_manifests(options, targets);
+
+    for target in targets.iter() {
+        // Replace any `:` characters and strip leading slashes
+        let target_path = target.replace(':', "/").trim_start_matches('/').to_owned();
+
+        // Find a manifest for the current target. Not all targets will have one
+        let manifest = options.workspace.join("bazel-bin").join(format!(
+            "{}.{}",
+            &target_path,
+            rustfmt_lib::RUSTFMT_MANIFEST_EXTENSION,
+        ));
+
+        if !manifest.exists() {
+            continue;
+        }
+
+        // Load the manifest containing rustfmt arguments
+        let rustfmt_config = rustfmt_lib::parse_rustfmt_manifest(&manifest);
+
+        // Ignore any targets which do not have source files. This can
+        // occur in cases where all source files are generated.
+        if rustfmt_config.sources.is_empty() {
+            continue;
+        }
+
+        // Run rustfmt
+        let status = Command::new(&options.rustfmt_config.rustfmt)
+            .current_dir(&options.workspace)
+            .arg("--edition")
+            .arg(rustfmt_config.edition)
+            .arg("--config-path")
+            .arg(&options.rustfmt_config.config)
+            .args(rustfmt_config.sources)
+            .status()
+            .expect("Failed to run rustfmt");
+
+        if !status.success() {
+            std::process::exit(status.code().unwrap_or(1));
+        }
+    }
+}
+
+/// A struct containing details used for executing rustfmt.
+#[derive(Debug)]
+struct Config {
+    /// The path of the Bazel workspace root.
+    pub workspace: PathBuf,
+
+    /// The Bazel executable to use for builds and queries.
+    pub bazel: PathBuf,
+
+    /// Information about the current rustfmt binary to run.
+    pub rustfmt_config: rustfmt_lib::RustfmtConfig,
+
+    /// Optionally, users can pass a list of targets/packages/scopes
+    /// (eg `//my:target` or `//my/pkg/...`) to control the targets
+    /// to be formatted. If empty, all targets in the workspace will
+    /// be formatted.
+    pub packages: Vec<String>,
+}
+
+/// Parse command line arguments and environment variables to
+/// produce config data for running rustfmt.
+fn parse_args() -> Config {
+    Config{
+        workspace: PathBuf::from(
+            env::var("BUILD_WORKSPACE_DIRECTORY")
+            .expect("The environment variable BUILD_WORKSPACE_DIRECTORY is required for finding the workspace root")
+        ),
+        bazel: PathBuf::from(
+            env::var("BAZEL_REAL")
+            .unwrap_or_else(|_| "bazel".to_owned())
+        ),
+        rustfmt_config: rustfmt_lib::parse_rustfmt_config(),
+        packages: env::args().skip(1).collect(),
+    }
+}
diff --git a/third_party/rules_rust/tools/rustfmt/srcs/test_main.rs b/third_party/rules_rust/tools/rustfmt/srcs/test_main.rs
new file mode 100644
index 0000000..ea2adba
--- /dev/null
+++ b/third_party/rules_rust/tools/rustfmt/srcs/test_main.rs
@@ -0,0 +1,95 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    // Gather all and environment settings
+    let options = parse_args();
+
+    // Perform rustfmt for each manifest available
+    run_rustfmt(&options);
+}
+
+/// Run rustfmt on a set of Bazel targets
+fn run_rustfmt(options: &Config) {
+    // In order to ensure the test parses all sources, we separately
+    // track whether or not a failure has occured when checking formatting.
+    let mut is_failure: bool = false;
+
+    for manifest in options.manifests.iter() {
+        // Ignore any targets which do not have source files. This can
+        // occur in cases where all source files are generated.
+        if manifest.sources.is_empty() {
+            continue;
+        }
+
+        // Run rustfmt
+        let status = Command::new(&options.rustfmt_config.rustfmt)
+            .arg("--check")
+            .arg("--edition")
+            .arg(&manifest.edition)
+            .arg("--config-path")
+            .arg(&options.rustfmt_config.config)
+            .args(&manifest.sources)
+            .status()
+            .expect("Failed to run rustfmt");
+
+        if !status.success() {
+            is_failure = true;
+        }
+    }
+
+    if is_failure {
+        std::process::exit(1);
+    }
+}
+
+/// A struct containing details used for executing rustfmt.
+#[derive(Debug)]
+struct Config {
+    /// Information about the current rustfmt binary to run.
+    pub rustfmt_config: rustfmt_lib::RustfmtConfig,
+
+    /// A list of manifests containing information about sources
+    /// to check using rustfmt.
+    pub manifests: Vec<rustfmt_lib::RustfmtManifest>,
+}
+
+/// Parse the runfiles of the current executable for manifests generated
+/// but the `rustfmt_aspect` aspect.
+fn find_manifests(dir: &Path, manifests: &mut Vec<PathBuf>) {
+    if dir.is_dir() {
+        for entry in fs::read_dir(dir).expect("Failed to read directory contents") {
+            let entry = entry.expect("Failed to read directory entry");
+            let path = entry.path();
+            if path.is_dir() {
+                find_manifests(&path, manifests);
+            } else if let Some(ext) = path.extension() {
+                if ext == rustfmt_lib::RUSTFMT_MANIFEST_EXTENSION {
+                    manifests.extend(vec![path]);
+                }
+            }
+        }
+    }
+}
+
+/// Parse settings from the environment into a config struct
+fn parse_args() -> Config {
+    let mut manifests: Vec<PathBuf> = Vec::new();
+    find_manifests(
+        &runfiles::find_runfiles_dir().expect("Failed to find runfiles directory"),
+        &mut manifests,
+    );
+
+    if manifests.is_empty() {
+        panic!("No manifests were found");
+    }
+
+    Config {
+        rustfmt_config: rustfmt_lib::parse_rustfmt_config(),
+        manifests: manifests
+            .iter()
+            .map(|manifest| rustfmt_lib::parse_rustfmt_manifest(manifest))
+            .collect(),
+    }
+}
diff --git a/third_party/rules_rust/tools/tool_utils.bzl b/third_party/rules_rust/tools/tool_utils.bzl
new file mode 100644
index 0000000..de876b1
--- /dev/null
+++ b/third_party/rules_rust/tools/tool_utils.bzl
@@ -0,0 +1,15 @@
+"""A helper module for the various targets in the `@rules_rust//tools` package"""
+
+def aspect_repository():
+    """Determines the repository name to use in Bazel commands that use aspects.
+
+    Some tools (`//tools/rustfmt` `//tools/rust_analyzer`) make calls to Bazel
+    and pass the `--aspects` flag. This macro allows those tools to work around
+    the following issue: https://github.com/bazelbuild/bazel/issues/11734
+
+    Returns:
+        str: The string to use for the `--aspects` repository labels
+    """
+    if native.repository_name() == "@":
+        return ""
+    return native.repository_name()
diff --git a/third_party/rules_rust/util/BUILD.bazel b/third_party/rules_rust/util/BUILD.bazel
new file mode 100644
index 0000000..217f1db
--- /dev/null
+++ b/third_party/rules_rust/util/BUILD.bazel
@@ -0,0 +1,4 @@
+sh_binary(
+    name = "fetch_shas",
+    srcs = ["fetch_shas.sh"],
+)
diff --git a/third_party/rules_rust/util/dir_zipper/BUILD.bazel b/third_party/rules_rust/util/dir_zipper/BUILD.bazel
new file mode 100644
index 0000000..43ab79e
--- /dev/null
+++ b/third_party/rules_rust/util/dir_zipper/BUILD.bazel
@@ -0,0 +1,8 @@
+load("//rust:defs.bzl", "rust_binary")
+
+rust_binary(
+    name = "dir_zipper",
+    srcs = ["dir_zipper.rs"],
+    edition = "2018",
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/util/dir_zipper/dir_zipper.rs b/third_party/rules_rust/util/dir_zipper/dir_zipper.rs
new file mode 100644
index 0000000..fbc4938
--- /dev/null
+++ b/third_party/rules_rust/util/dir_zipper/dir_zipper.rs
@@ -0,0 +1,77 @@
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::process::Command;
+
+const USAGE: &str = r#"usage: dir_zipper <zipper> <output> <root-dir> [<file>...]
+
+Creates a zip archive, stripping a directory prefix from each file name.
+
+Args:
+  zipper: Path to @bazel_tools//tools/zip:zipper.
+  output: Path to zip file to create: e.g., "/tmp/out.zip".
+  root_dir: Directory to strip from each archive name, with no trailing
+    slash: e.g., "/tmp/myfiles".
+  files: List of files to include in the archive, all under `root_dir`:
+    e.g., ["/tmp/myfiles/a", "/tmp/myfiles/b/c"].
+
+Example:
+  dir_zipper \
+    bazel-rules_rust/external/bazel_tools/tools/zip/zipper/zipper \
+    /tmp/out.zip \
+    /tmp/myfiles \
+    /tmp/myfiles/a /tmp/myfiles/b/c
+
+This will create /tmp/out.zip with file entries "a" and "b/c".
+"#;
+
+macro_rules! die {
+    ($($arg:tt)*) => {
+        {
+            eprintln!($($arg)*);
+            std::process::exit(1);
+        }
+    };
+}
+
+fn main() {
+    let mut args = std::env::args_os().skip(1);
+    let (zipper, output, root_dir) = match args.next().zip(args.next()).zip(args.next()) {
+        Some(((zipper, output), root_dir)) => (
+            PathBuf::from(zipper),
+            PathBuf::from(output),
+            PathBuf::from(root_dir),
+        ),
+        _ => {
+            die!("{}", USAGE);
+        }
+    };
+    let files = args.map(PathBuf::from).collect::<Vec<_>>();
+    let mut comm = Command::new(zipper);
+    comm.arg("c"); // create, but don't compress
+    comm.arg(output);
+    for f in files {
+        let rel = f.strip_prefix(&root_dir).unwrap_or_else(|_e| {
+            die!(
+                "fatal: non-descendant: {} not under {}",
+                f.display(),
+                root_dir.display()
+            );
+        });
+        let mut spec = OsString::new();
+        spec.push(rel);
+        spec.push("=");
+        spec.push(f);
+        comm.arg(spec);
+    }
+    let exit_status = comm
+        .spawn()
+        .unwrap_or_else(|e| die!("fatal: could not spawn zipper: {}", e))
+        .wait()
+        .unwrap_or_else(|e| die!("fatal: could not wait on zipper: {}", e));
+    if !exit_status.success() {
+        match exit_status.code() {
+            Some(c) => std::process::exit(c),
+            None => die!("fatal: zipper terminated by signal"),
+        }
+    }
+}
diff --git a/third_party/rules_rust/util/fetch_shas.sh b/third_party/rules_rust/util/fetch_shas.sh
new file mode 100755
index 0000000..2a538c1
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas.sh
@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+
+# Enumerates the list of expected downloadable files, loads the SHAs for each file, then
+# dumps the result to //rust:known_shas.bzl
+
+export LC_ALL=C
+
+# Detect workspace root
+if [[ -z "${BUILD_WORKSPACE_DIRECTORY}" ]]; then
+    SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+    BUILD_WORKSPACE_DIRECTORY="$( dirname "${SCRIPT_DIR}")"
+fi
+
+TOOLS="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_TOOLS.txt")"
+HOST_TOOLS="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_HOST_TOOLS.txt")"
+TARGETS="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_TARGETS.txt")"
+VERSIONS="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_VERSIONS.txt")"
+BETA_ISO_DATES="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_BETA_ISO_DATES.txt")"
+NIGHTLY_ISO_DATES="$(cat "${BUILD_WORKSPACE_DIRECTORY}/util/fetch_shas_NIGHTLY_ISO_DATES.txt")"
+
+enumerate_keys() {
+  for TOOL in $TOOLS
+  do
+    for TARGET in $TARGETS
+    do
+      for VERSION in $VERSIONS
+      do
+        echo "$TOOL-$VERSION-$TARGET"
+      done
+
+      for ISO_DATE in $BETA_ISO_DATES
+      do
+        echo "$ISO_DATE/$TOOL-beta-$TARGET"
+      done
+
+      for ISO_DATE in $NIGHTLY_ISO_DATES
+      do
+        echo "$ISO_DATE/$TOOL-nightly-$TARGET"
+      done
+    done
+  done
+
+  for HOST_TOOL in $HOST_TOOLS
+  do
+    for VERSION in $VERSIONS
+    do
+      echo "$HOST_TOOL-$VERSION"
+    done
+  done
+}
+
+emit_bzl_file_contents() {
+  echo "$@" \
+    | parallel --trim lr -d ' ' --will-cite 'printf "%s %s\n", {}, $(curl --fail https://static.rust-lang.org/dist/{}.tar.gz.sha256 | cut -f1 -d" ")' \
+    | sed "s/,//g" \
+    | grep -v " $" \
+    > /tmp/reload_shas_shalist.txt
+
+  echo "\"\"\"A module containing a mapping of Rust tools to checksums"
+  echo ""
+  echo "This is a generated file -- see //util:fetch_shas"
+  echo "\"\"\""
+  echo ""
+  echo "FILE_KEY_TO_SHA = {"
+  cat /tmp/reload_shas_shalist.txt | sed '/^[[:space:]]*$/d' | sort | awk '{print "    \"" $1 "\": \"" $2 "\","}'
+  echo "}"
+  rm /tmp/reload_shas_shalist.txt
+}
+
+echo "$(emit_bzl_file_contents $(enumerate_keys))" > "${BUILD_WORKSPACE_DIRECTORY}/rust/known_shas.bzl"
diff --git a/third_party/rules_rust/util/fetch_shas_BETA_ISO_DATES.txt b/third_party/rules_rust/util/fetch_shas_BETA_ISO_DATES.txt
new file mode 100644
index 0000000..8e7996c
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_BETA_ISO_DATES.txt
@@ -0,0 +1,4 @@
+2018-10-30
+2018-11-01
+2018-11-02
+2020-12-30
diff --git a/third_party/rules_rust/util/fetch_shas_HOST_TOOLS.txt b/third_party/rules_rust/util/fetch_shas_HOST_TOOLS.txt
new file mode 100644
index 0000000..1a3bdb2
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_HOST_TOOLS.txt
@@ -0,0 +1 @@
+rust-src
diff --git a/third_party/rules_rust/util/fetch_shas_NIGHTLY_ISO_DATES.txt b/third_party/rules_rust/util/fetch_shas_NIGHTLY_ISO_DATES.txt
new file mode 100644
index 0000000..2d9a94e
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_NIGHTLY_ISO_DATES.txt
@@ -0,0 +1,14 @@
+2018-11-07
+2018-11-08
+2018-11-09
+2020-02-16
+2020-11-10
+2020-12-30
+2021-06-16
+2021-09-08
+2021-10-21
+2021-11-07
+2021-12-01
+2022-01-12
+2022-01-19
+2022-02-23
diff --git a/third_party/rules_rust/util/fetch_shas_TARGETS.txt b/third_party/rules_rust/util/fetch_shas_TARGETS.txt
new file mode 100644
index 0000000..e5bacb4
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_TARGETS.txt
@@ -0,0 +1,10 @@
+aarch64-apple-darwin
+aarch64-unknown-linux-gnu
+aarch64-unknown-linux-musl
+wasm32-unknown-unknown
+wasm32-wasi
+x86_64-apple-darwin
+x86_64-pc-windows-msvc
+x86_64-unknown-freebsd
+x86_64-unknown-linux-gnu
+x86_64-unknown-linux-musl
diff --git a/third_party/rules_rust/util/fetch_shas_TOOLS.txt b/third_party/rules_rust/util/fetch_shas_TOOLS.txt
new file mode 100644
index 0000000..cf0f7c8
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_TOOLS.txt
@@ -0,0 +1,7 @@
+cargo
+clippy
+llvm-tools
+rust
+rust-std
+rustc
+rustfmt
diff --git a/third_party/rules_rust/util/fetch_shas_VERSIONS.txt b/third_party/rules_rust/util/fetch_shas_VERSIONS.txt
new file mode 100644
index 0000000..18ad30c
--- /dev/null
+++ b/third_party/rules_rust/util/fetch_shas_VERSIONS.txt
@@ -0,0 +1,45 @@
+1.26.0
+1.26.1
+1.26.2
+1.27.0
+1.27.1
+1.27.2
+1.28.0
+1.29.0
+1.29.1
+1.29.2
+1.30.0
+1.30.1
+1.31.0
+1.31.1
+1.32.0
+1.33.0
+1.34.0
+1.35.0
+1.36.0
+1.37.0
+1.38.0
+1.39.0
+1.40.0
+1.41.0
+1.42.0
+1.43.0
+1.44.0
+1.45.0
+1.46.0
+1.47.0
+1.48.0
+1.49.0
+1.50.0
+1.51.0
+1.52.0
+1.52.1
+1.53.0
+1.54.0
+1.55.0
+1.56.0
+1.56.1
+1.57.0
+1.58.0
+1.58.1
+1.59.0
diff --git a/third_party/rules_rust/util/import/BUILD.bazel b/third_party/rules_rust/util/import/BUILD.bazel
new file mode 100644
index 0000000..7cb0395
--- /dev/null
+++ b/third_party/rules_rust/util/import/BUILD.bazel
@@ -0,0 +1,73 @@
+load("//rust:defs.bzl", "rust_library", "rust_proc_macro", "rust_test")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:transitions.bzl", "with_import_macro_bootstrapping_mode")
+
+with_import_macro_bootstrapping_mode(
+    name = "import_macro",
+    target = "import_macro_impl",
+)
+
+rust_proc_macro(
+    name = "import_macro_impl",
+    srcs = [
+        "import.rs",
+    ],
+    crate_name = "import",
+    deps = [
+        ":import_internal",
+        "//util/import/raze:syn",
+    ],
+)
+
+rust_library(
+    name = "import_internal",
+    srcs = [
+        "import_internal.rs",
+    ],
+    deps = [
+        "//util/import/raze:aho_corasick",
+        "//util/import/raze:lazy_static",
+        "//util/import/raze:proc_macro2",
+        "//util/import/raze:quote",
+        "//util/import/raze:syn",
+        "//util/label",
+    ],
+)
+
+rust_test(
+    name = "import_internal_test",
+    crate = ":import_internal",
+    deps = [
+        "//util/import/raze:quickcheck",
+    ],
+)
+
+alias(
+    name = "import",
+    actual = select({
+        ":use_fake_import_macro": ":fake_import_macro_impl",
+        "//conditions:default": ":import_macro_label",
+    }),
+    visibility = ["//visibility:public"],
+)
+
+# This is there to cut the loading-time dependency on the import macro dependencies
+# (so users who don't use the macro don't need to add those deps to their WORKSPACE
+# file). Bazel in the loading phase doesn't "see" through `label_flag`.
+label_flag(
+    name = "import_macro_label",
+    build_setting_default = "import_macro",
+)
+
+config_setting(
+    name = "use_fake_import_macro",
+    flag_values = {
+        "@rules_rust//rust/settings:use_real_import_macro": "False",
+    },
+)
+
+sh_binary(
+    name = "fake_import_macro_impl",
+    srcs = ["fake_import_macro_impl.sh"],
+)
diff --git a/third_party/rules_rust/util/import/deps.bzl b/third_party/rules_rust/util/import/deps.bzl
new file mode 100644
index 0000000..be49b06
--- /dev/null
+++ b/third_party/rules_rust/util/import/deps.bzl
@@ -0,0 +1,11 @@
+"""
+The dependencies for running the gen_rust_project binary.
+"""
+
+load("//util/import/raze:crates.bzl", "rules_rust_util_import_fetch_remote_crates")
+
+def import_deps():
+    rules_rust_util_import_fetch_remote_crates()
+
+# For legacy support
+gen_rust_project_dependencies = import_deps
diff --git a/third_party/rules_rust/util/import/fake_import_macro_impl.sh b/third_party/rules_rust/util/import/fake_import_macro_impl.sh
new file mode 100755
index 0000000..1fa77d8
--- /dev/null
+++ b/third_party/rules_rust/util/import/fake_import_macro_impl.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+# Does nothing.
\ No newline at end of file
diff --git a/third_party/rules_rust/util/import/import.rs b/third_party/rules_rust/util/import/import.rs
new file mode 100644
index 0000000..fff5e78
--- /dev/null
+++ b/third_party/rules_rust/util/import/import.rs
@@ -0,0 +1,19 @@
+use syn::parse_macro_input;
+
+fn mode() -> import_internal::Mode {
+    match std::env::var("RULES_RUST_THIRD_PARTY_DIR")
+        .ok()
+        .and_then(|dir| dir.strip_prefix("//").map(|s| s.to_string()))
+    {
+        Some(third_party_dir) => import_internal::Mode::RenameFirstPartyCrates { third_party_dir },
+        _ => import_internal::Mode::NoRenaming,
+    }
+}
+
+#[proc_macro]
+pub fn import(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as import_internal::ImportMacroInput);
+    import_internal::expand_imports(input, &mode())
+        .unwrap_or_else(|errors| errors.into_iter().map(|e| e.into_compile_error()).collect())
+        .into()
+}
diff --git a/third_party/rules_rust/util/import/import_internal.rs b/third_party/rules_rust/util/import/import_internal.rs
new file mode 100644
index 0000000..1d44fe6
--- /dev/null
+++ b/third_party/rules_rust/util/import/import_internal.rs
@@ -0,0 +1,554 @@
+use std::iter;
+use std::vec;
+
+use aho_corasick::AhoCorasick;
+use lazy_static::lazy_static;
+use proc_macro2::{Span, TokenStream};
+use quote::quote_spanned;
+use syn::parse::{Parse, ParseStream};
+use syn::{Error, Ident, Lit, LitStr, Result, Token};
+
+/// The possible renaming modes for this macro.
+pub enum Mode {
+    /// No renaming will be done; the expansion will replace each label with
+    /// just the target.
+    NoRenaming,
+    /// First-party crates will be renamed, and third-party crates will not be.
+    /// The expansion will replace first-party labels with an encoded version,
+    /// and third-party labels with just their target.
+    RenameFirstPartyCrates { third_party_dir: String },
+}
+
+/// A special case of label::Label, which must be absolute and must not specify
+/// a repository.
+#[derive(Debug, PartialEq)]
+struct AbsoluteLabel<'s> {
+    package_name: &'s str,
+    name: &'s str,
+}
+
+impl<'s> AbsoluteLabel<'s> {
+    /// Parses a string as an absolute Bazel label. Labels must be for the
+    /// current repository.
+    fn parse(label: &'s str, span: &'s Span) -> Result<Self> {
+        if let Ok(label::Label {
+            repository_name: None,
+            package_name: Some(package_name),
+            name,
+        }) = label::analyze(label)
+        {
+            Ok(AbsoluteLabel { package_name, name })
+        } else {
+            Err(Error::new(
+                *span,
+                "Bazel labels must be of the form '//package[:target]'",
+            ))
+        }
+    }
+
+    /// Returns true iff this label should be renamed.
+    fn should_rename(&self, mode: &Mode) -> bool {
+        match mode {
+            Mode::NoRenaming => false,
+            Mode::RenameFirstPartyCrates { third_party_dir } => {
+                !self.package_name.starts_with(third_party_dir)
+            }
+        }
+    }
+
+    /// Returns the appropriate (encoded) alias to use, if this label is being
+    /// renamed; otherwise, returns None.
+    fn target_as_alias(&self, mode: &Mode) -> Option<String> {
+        self.should_rename(mode).then(|| encode(self.name))
+    }
+
+    /// Returns the full crate name, encoded if necessary.
+    fn crate_name(&self, mode: &Mode) -> String {
+        if self.should_rename(mode) {
+            encode(&format!("{}:{}", self.package_name, self.name))
+        } else {
+            self.name.to_string()
+        }
+    }
+}
+
+lazy_static! {
+    // Transformations are stored as "(unencoded, encoded)" tuples.
+    // Target names can include:
+    // !%-@^_` "#$&'()*-+,;<=>?[]{|}~/.
+    //
+    // Package names are alphanumeric, plus [_/-].
+    //
+    // Packages and targets are separated by colons.
+    static ref SUBSTITUTIONS: (Vec<String>, Vec<String>) =
+        iter::once(("_quote".to_string(), "_quotequote_".to_string()))
+        .chain(
+            vec![
+                    (":", "colon"),
+                    ("!", "bang"),
+                    ("%", "percent"),
+                    ("@", "at"),
+                    ("^", "caret"),
+                    ("`", "backtick"),
+                    (" ", "space"),
+                    ("\"", "quote"),
+                    ("#", "hash"),
+                    ("$", "dollar"),
+                    ("&", "ampersand"),
+                    ("'", "backslash"),
+                    ("(", "lparen"),
+                    (")", "rparen"),
+                    ("*", "star"),
+                    ("-", "dash"),
+                    ("+", "plus"),
+                    (",", "comma"),
+                    (";", "semicolon"),
+                    ("<", "langle"),
+                    ("=", "equal"),
+                    (">", "rangle"),
+                    ("?", "question"),
+                    ("[", "lbracket"),
+                    ("]", "rbracket"),
+                    ("{", "lbrace"),
+                    ("|", "pipe"),
+                    ("}", "rbrace"),
+                    ("~", "tilde"),
+                    ("/", "slash"),
+                    (".", "dot"),
+            ].into_iter()
+            .flat_map(|pair| {
+                vec![
+                    (format!("_{}_", &pair.1), format!("_quote{}_", &pair.1)),
+                    (pair.0.to_string(), format!("_{}_", &pair.1)),
+                ].into_iter()
+            })
+        )
+        .unzip();
+
+    static ref ENCODER: AhoCorasick = AhoCorasick::new(&SUBSTITUTIONS.0);
+    static ref DECODER: AhoCorasick = AhoCorasick::new(&SUBSTITUTIONS.1);
+}
+
+/// Encodes a string using the above encoding scheme.
+fn encode(s: &str) -> String {
+    ENCODER.replace_all(s, &SUBSTITUTIONS.1)
+}
+
+struct Import {
+    label: LitStr,
+    alias: Option<Ident>,
+}
+
+impl Import {
+    fn try_into_statement(self, mode: &Mode) -> Result<proc_macro2::TokenStream> {
+        let label_literal = &self.label.value();
+        let span = self.label.span();
+        let label = AbsoluteLabel::parse(label_literal, &span)?;
+        let crate_name = &label.crate_name(mode);
+
+        let crate_ident = Ident::new(crate_name, span);
+        let alias = self
+            .alias
+            .or_else(|| {
+                label
+                    .target_as_alias(mode)
+                    .map(|alias| Ident::new(&alias, span))
+            })
+            .filter(|alias| alias != crate_name);
+
+        Ok(if let Some(alias) = alias {
+            quote_spanned! {span=> extern crate #crate_ident as #alias; }
+        } else {
+            quote_spanned! {span=> extern crate #crate_ident;}
+        })
+    }
+}
+
+pub struct ImportMacroInput {
+    imports: Vec<Import>,
+}
+
+impl Parse for ImportMacroInput {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut imports: Vec<Import> = Vec::new();
+
+        while !input.is_empty() {
+            let label = match Lit::parse(input)
+                .map_err(|_| input.error("expected Bazel label as a string literal"))?
+            {
+                Lit::Str(label) => label,
+                lit => {
+                    return Err(input.error(format!(
+                        "expected Bazel label as string literal, found '{}' literal",
+                        quote::quote! {#lit}
+                    )));
+                }
+            };
+            let alias = if input.peek(Token![as]) {
+                <Token![as]>::parse(input)?;
+                Some(
+                    Ident::parse(input)
+                        .map_err(|_| input.error("alias must be a valid Rust identifier"))?,
+                )
+            } else {
+                None
+            };
+            imports.push(Import { label, alias });
+            <syn::Token![;]>::parse(input)?;
+        }
+
+        Ok(Self { imports })
+    }
+}
+
+pub fn expand_imports(
+    input: ImportMacroInput,
+    mode: &Mode,
+) -> std::result::Result<TokenStream, Vec<syn::Error>> {
+    let (statements, errs): (Vec<_>, Vec<_>) = input
+        .imports
+        .into_iter()
+        .map(|i| i.try_into_statement(mode))
+        .partition(Result::is_ok);
+
+    if !errs.is_empty() {
+        Err(errs.into_iter().map(Result::unwrap_err).collect())
+    } else {
+        Ok(statements.into_iter().map(Result::unwrap).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    use quickcheck::quickcheck;
+    use syn::parse_quote;
+
+    /// Decodes a string that was encoded using `encode`.
+    fn decode(s: &str) -> String {
+        DECODER.replace_all(s, &SUBSTITUTIONS.0)
+    }
+
+    #[test]
+    fn test_expand_imports_without_renaming() -> std::result::Result<(), Vec<syn::Error>> {
+        let mode = Mode::NoRenaming;
+
+        // Nothing to do.
+        let expanded = expand_imports(parse_quote! {}, &mode)?;
+        assert_eq!(expanded.to_string(), "");
+
+        // Package and a target.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils"; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils ;");
+
+        // Package and a target, with a no-op alias.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils"; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils ;");
+
+        // Package and a target, with an alias.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils" as my_utils; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils as my_utils ;");
+
+        // Package and an implicit target.
+        let expanded = expand_imports(parse_quote! { "//some_project/utils"; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils ;");
+
+        // Package and an implicit target, with a no-op alias.
+        let expanded = expand_imports(parse_quote! { "//some_project/utils" as utils; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils ;");
+
+        // Package and an implicit target, with an alias.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils" as my_utils; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate utils as my_utils ;");
+
+        // A third-party target.
+        let expanded =
+            expand_imports(parse_quote! { "//third_party/rust/serde/v1:serde"; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate serde ;");
+
+        // A third-party target with a no-op alias.
+        let expanded = expand_imports(
+            parse_quote! { "//third_party/rust/serde/v1:serde" as serde; },
+            &mode,
+        )?;
+        assert_eq!(expanded.to_string(), "extern crate serde ;");
+
+        // A third-party target with an alias.
+        let expanded = expand_imports(
+            parse_quote! { "//third_party/rust/serde/v1:serde" as my_serde; },
+            &mode,
+        )?;
+        assert_eq!(expanded.to_string(), "extern crate serde as my_serde ;");
+
+        // Multiple targets.
+        let expanded = expand_imports(
+            parse_quote! { "//some_project:utils"; "//third_party/rust/serde/v1:serde"; },
+            &mode,
+        )?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate utils ; extern crate serde ;"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_expand_imports_with_renaming() -> std::result::Result<(), Vec<syn::Error>> {
+        let mode = Mode::RenameFirstPartyCrates {
+            third_party_dir: "third_party/rust".to_string(),
+        };
+
+        // Nothing to do.
+        let expanded = expand_imports(parse_quote! {}, &mode)?;
+        assert_eq!(expanded.to_string(), "");
+
+        // Package and a target.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils"; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_utils as utils ;"
+        );
+
+        // Package and a target, with a no-op alias.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils" as utils; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_utils as utils ;"
+        );
+
+        // Package and a target, with an alias.
+        let expanded = expand_imports(parse_quote! { "//some_project:utils" as my_utils; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_utils as my_utils ;"
+        );
+
+        // Package and an implicit target.
+        let expanded = expand_imports(parse_quote! { "//some_project/utils"; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_slash_utils_colon_utils as utils ;"
+        );
+
+        // Package and an implicit target, with a no-op alias.
+        let expanded = expand_imports(parse_quote! { "//some_project/utils" as utils; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_slash_utils_colon_utils as utils ;"
+        );
+
+        // Package and an implicit target, with an alias.
+        let expanded = expand_imports(parse_quote! { "//some_project/utils" as my_utils; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_slash_utils_colon_utils as my_utils ;"
+        );
+
+        // A third-party target.
+        let expanded =
+            expand_imports(parse_quote! { "//third_party/rust/serde/v1:serde"; }, &mode)?;
+        assert_eq!(expanded.to_string(), "extern crate serde ;");
+
+        // A third-party target with a no-op alias.
+        let expanded = expand_imports(
+            parse_quote! { "//third_party/rust/serde/v1:serde" as serde; },
+            &mode,
+        )?;
+        assert_eq!(expanded.to_string(), "extern crate serde ;");
+
+        // A third-party target with an alias.
+        let expanded = expand_imports(
+            parse_quote! { "//third_party/rust/serde/v1:serde" as my_serde; },
+            &mode,
+        )?;
+        assert_eq!(expanded.to_string(), "extern crate serde as my_serde ;");
+
+        // Multiple targets.
+        let expanded = expand_imports(
+            parse_quote! { "//some_project:utils"; "//third_party/rust/serde/v1:serde"; },
+            &mode,
+        )?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_utils as utils ; extern crate serde ;"
+        );
+
+        // Problematic target name.
+        let expanded = expand_imports(parse_quote! { "//some_project:thing-types"; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_thing_dash_types as thing_dash_types ;"
+        );
+
+        // Problematic target name with alias.
+        let expanded = expand_imports(
+            parse_quote! { "//some_project:thing-types" as types; },
+            &mode,
+        )?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_colon_thing_dash_types as types ;"
+        );
+
+        // Problematic package name.
+        let expanded = expand_imports(parse_quote! { "//some_project-prototype:utils"; }, &mode)?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_dash_prototype_colon_utils as utils ;"
+        );
+
+        // Problematic package and target names.
+        let expanded = expand_imports(
+            parse_quote! { "//some_project-prototype:thing-types"; },
+            &mode,
+        )?;
+        assert_eq!(
+            expanded.to_string(),
+            "extern crate some_project_dash_prototype_colon_thing_dash_types as thing_dash_types ;"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_expansion_failures() -> Result<()> {
+        let mode = Mode::NoRenaming;
+
+        // Missing leading "//", not a valid label.
+        let errs = expand_imports(parse_quote! { "some_project:utils"; }, &mode).unwrap_err();
+        assert_eq!(
+            errs.into_iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<String>>(),
+            vec!["Bazel labels must be of the form '//package[:target]'"]
+        );
+
+        // Valid label, but relative.
+        let errs = expand_imports(parse_quote! { ":utils"; }, &mode).unwrap_err();
+        assert_eq!(
+            errs.into_iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<String>>(),
+            vec!["Bazel labels must be of the form '//package[:target]'"]
+        );
+
+        // Valid label, but a wildcard.
+        let errs = expand_imports(parse_quote! { "some_project/..."; }, &mode).unwrap_err();
+        assert_eq!(
+            errs.into_iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<String>>(),
+            vec!["Bazel labels must be of the form '//package[:target]'"]
+        );
+
+        // Valid label, but only in Bazel (not in Bazel).
+        let errs =
+            expand_imports(parse_quote! { "@repository//some_project:utils"; }, &mode).unwrap_err();
+        assert_eq!(
+            errs.into_iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<String>>(),
+            vec!["Bazel labels must be of the form '//package[:target]'"]
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_macro_input_parsing_errors() -> Result<()> {
+        // Label is not a string literal.
+        assert_eq!(
+            syn::parse_str::<ImportMacroInput>("some_project:utils;")
+                .err()
+                .unwrap()
+                .to_string(),
+            "expected Bazel label as a string literal"
+        );
+
+        // Label is the wrong kind of literal.
+        assert_eq!(
+            syn::parse_str::<ImportMacroInput>("true;")
+                .err()
+                .unwrap()
+                .to_string(),
+            "expected Bazel label as string literal, found 'true' literal"
+        );
+        assert_eq!(
+            syn::parse_str::<ImportMacroInput>("123;")
+                .err()
+                .unwrap()
+                .to_string(),
+            "expected Bazel label as string literal, found '123' literal"
+        );
+
+        // Alias is not a valid identifier.
+        assert_eq!(
+            syn::parse_str::<ImportMacroInput>(r#""some_project:utils" as "!@#$%";"#)
+                .err()
+                .unwrap()
+                .to_string(),
+            "alias must be a valid Rust identifier"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_label_parsing() -> Result<()> {
+        assert_eq!(
+            AbsoluteLabel::parse("//some_project:utils", &Span::call_site())?,
+            AbsoluteLabel {
+                package_name: "some_project",
+                name: "utils"
+            },
+        );
+        assert_eq!(
+            AbsoluteLabel::parse("//some_project/utils", &Span::call_site())?,
+            AbsoluteLabel {
+                package_name: "some_project/utils",
+                name: "utils"
+            },
+        );
+        assert_eq!(
+            AbsoluteLabel::parse("//some_project", &Span::call_site())?,
+            AbsoluteLabel {
+                package_name: "some_project",
+                name: "some_project"
+            },
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_encode() -> Result<()> {
+        assert_eq!(encode("some_project:utils"), "some_project_colon_utils");
+        assert_eq!(&encode("_quotedot_"), "_quotequote_dot_");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_decode() -> Result<()> {
+        assert_eq!(decode("some_project_colon_utils"), "some_project:utils");
+        assert_eq!(decode("_quotequote_dot_"), "_quotedot_");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_substitutions_compose() -> Result<()> {
+        for s in SUBSTITUTIONS.0.iter().chain(SUBSTITUTIONS.1.iter()) {
+            assert_eq!(&decode(&encode(s)), s);
+        }
+
+        Ok(())
+    }
+
+    quickcheck! {
+        fn composition_is_identity(s: String) -> bool {
+            s == decode(&encode(&s))
+        }
+    }
+}
diff --git a/third_party/rules_rust/util/import/raze/BUILD.bazel b/third_party/rules_rust/util/import/raze/BUILD.bazel
new file mode 100644
index 0000000..2f14d0e
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/BUILD.bazel
@@ -0,0 +1,75 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "aho_corasick",
+    actual = "@rules_rust_util_import__aho_corasick__0_7_15//:aho_corasick",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "lazy_static",
+    actual = "@rules_rust_util_import__lazy_static__1_4_0//:lazy_static",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "proc_macro2",
+    actual = "@rules_rust_util_import__proc_macro2__1_0_33//:proc_macro2",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "quickcheck",
+    actual = "@rules_rust_util_import__quickcheck__1_0_3//:quickcheck",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "quote",
+    actual = "@rules_rust_util_import__quote__1_0_10//:quote",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "syn",
+    actual = "@rules_rust_util_import__syn__1_0_82//:syn",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/util/import/raze/Cargo.raze.lock b/third_party/rules_rust/util/import/raze/Cargo.raze.lock
new file mode 100644
index 0000000..72b143b
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/Cargo.raze.lock
@@ -0,0 +1,163 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "aho-corasick"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "compile_with_bazel"
+version = "0.0.0"
+dependencies = [
+ "aho-corasick",
+ "lazy_static",
+ "proc-macro2",
+ "quickcheck",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb37d2df5df740e582f28f8560cf425f52bb267d872fe58358eadb554909f07a"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "env_logger",
+ "log",
+ "rand",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "regex"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "syn"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8daf5dd0bb60cbd4137b1b587d2fc0ae729bc07cf01cd70b36a1ed5ade3b9d59"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
diff --git a/third_party/rules_rust/util/import/raze/Cargo.toml b/third_party/rules_rust/util/import/raze/Cargo.toml
new file mode 100644
index 0000000..b942944
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "compile_with_bazel"
+version = "0.0.0"
+
+# Mandatory (or Cargo tooling is unhappy)
+[lib]
+path = "fake_lib.rs"
+
+[dependencies]
+aho-corasick = "=0.7.15"
+lazy_static = "=1.4.0"
+proc-macro2 = "=1.0.33"
+quote = "=1.0.10"
+syn = "=1.0.82"
+
+[dev-dependencies]
+quickcheck = "=1.0.3"
+
+[package.metadata.raze]
+genmode = "Remote"
+workspace_path = "//util/import/raze"
+gen_workspace_prefix = "rules_rust_util_import"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "."
+default_gen_buildrs = true
\ No newline at end of file
diff --git a/third_party/rules_rust/util/import/raze/crates.bzl b/third_party/rules_rust/util/import/raze/crates.bzl
new file mode 100644
index 0000000..7da9f98
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/crates.bzl
@@ -0,0 +1,192 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def rules_rust_util_import_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__aho_corasick__0_7_15",
+        url = "https://crates.io/api/v1/crates/aho-corasick/0.7.15/download",
+        type = "tar.gz",
+        sha256 = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5",
+        strip_prefix = "aho-corasick-0.7.15",
+        build_file = Label("//util/import/raze/remote:BUILD.aho-corasick-0.7.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__cfg_if__1_0_0",
+        url = "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("//util/import/raze/remote:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__env_logger__0_8_4",
+        url = "https://crates.io/api/v1/crates/env_logger/0.8.4/download",
+        type = "tar.gz",
+        sha256 = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3",
+        strip_prefix = "env_logger-0.8.4",
+        build_file = Label("//util/import/raze/remote:BUILD.env_logger-0.8.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__getrandom__0_2_3",
+        url = "https://crates.io/api/v1/crates/getrandom/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753",
+        strip_prefix = "getrandom-0.2.3",
+        build_file = Label("//util/import/raze/remote:BUILD.getrandom-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//util/import/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__libc__0_2_112",
+        url = "https://crates.io/api/v1/crates/libc/0.2.112/download",
+        type = "tar.gz",
+        sha256 = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125",
+        strip_prefix = "libc-0.2.112",
+        build_file = Label("//util/import/raze/remote:BUILD.libc-0.2.112.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__log__0_4_14",
+        url = "https://crates.io/api/v1/crates/log/0.4.14/download",
+        type = "tar.gz",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        strip_prefix = "log-0.4.14",
+        build_file = Label("//util/import/raze/remote:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__memchr__2_4_1",
+        url = "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+        type = "tar.gz",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("//util/import/raze/remote:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__proc_macro2__1_0_33",
+        url = "https://crates.io/api/v1/crates/proc-macro2/1.0.33/download",
+        type = "tar.gz",
+        sha256 = "fb37d2df5df740e582f28f8560cf425f52bb267d872fe58358eadb554909f07a",
+        strip_prefix = "proc-macro2-1.0.33",
+        build_file = Label("//util/import/raze/remote:BUILD.proc-macro2-1.0.33.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__quickcheck__1_0_3",
+        url = "https://crates.io/api/v1/crates/quickcheck/1.0.3/download",
+        type = "tar.gz",
+        sha256 = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6",
+        strip_prefix = "quickcheck-1.0.3",
+        build_file = Label("//util/import/raze/remote:BUILD.quickcheck-1.0.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__quote__1_0_10",
+        url = "https://crates.io/api/v1/crates/quote/1.0.10/download",
+        type = "tar.gz",
+        sha256 = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05",
+        strip_prefix = "quote-1.0.10",
+        build_file = Label("//util/import/raze/remote:BUILD.quote-1.0.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__rand__0_8_4",
+        url = "https://crates.io/api/v1/crates/rand/0.8.4/download",
+        type = "tar.gz",
+        sha256 = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8",
+        strip_prefix = "rand-0.8.4",
+        build_file = Label("//util/import/raze/remote:BUILD.rand-0.8.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__rand_core__0_6_3",
+        url = "https://crates.io/api/v1/crates/rand_core/0.6.3/download",
+        type = "tar.gz",
+        sha256 = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7",
+        strip_prefix = "rand_core-0.6.3",
+        build_file = Label("//util/import/raze/remote:BUILD.rand_core-0.6.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__regex__1_4_6",
+        url = "https://crates.io/api/v1/crates/regex/1.4.6/download",
+        type = "tar.gz",
+        sha256 = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759",
+        strip_prefix = "regex-1.4.6",
+        build_file = Label("//util/import/raze/remote:BUILD.regex-1.4.6.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__regex_syntax__0_6_25",
+        url = "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+        type = "tar.gz",
+        sha256 = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b",
+        strip_prefix = "regex-syntax-0.6.25",
+        build_file = Label("//util/import/raze/remote:BUILD.regex-syntax-0.6.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__syn__1_0_82",
+        url = "https://crates.io/api/v1/crates/syn/1.0.82/download",
+        type = "tar.gz",
+        sha256 = "8daf5dd0bb60cbd4137b1b587d2fc0ae729bc07cf01cd70b36a1ed5ade3b9d59",
+        strip_prefix = "syn-1.0.82",
+        build_file = Label("//util/import/raze/remote:BUILD.syn-1.0.82.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__unicode_xid__0_2_2",
+        url = "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+        type = "tar.gz",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("//util/import/raze/remote:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_util_import__wasi__0_10_2_wasi_snapshot_preview1",
+        url = "https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download",
+        type = "tar.gz",
+        sha256 = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6",
+        strip_prefix = "wasi-0.10.2+wasi-snapshot-preview1",
+        build_file = Label("//util/import/raze/remote:BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel"),
+    )
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.aho-corasick-0.7.15.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.aho-corasick-0.7.15.bazel
new file mode 100644
index 0000000..4fc8c0d
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.aho-corasick-0.7.15.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "aho_corasick",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=aho_corasick",
+        "manual",
+    ],
+    version = "0.7.15",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__memchr__2_4_1//:memchr",
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..1a5adcf
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=cfg-if",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.env_logger-0.8.4.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.env_logger-0.8.4.bazel
new file mode 100644
index 0000000..a04b02c
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.env_logger-0.8.4.bazel
@@ -0,0 +1,65 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "env_logger",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "regex",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=env_logger",
+        "manual",
+    ],
+    version = "0.8.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__log__0_4_14//:log",
+        "@rules_rust_util_import__regex__1_4_6//:regex",
+    ],
+)
+
+# Unsupported target "init-twice-retains-filter" with type "test" omitted
+
+# Unsupported target "log-in-log" with type "test" omitted
+
+# Unsupported target "log_tls_dtors" with type "test" omitted
+
+# Unsupported target "regexp_filter" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.getrandom-0.2.3.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.getrandom-0.2.3.bazel
new file mode 100644
index 0000000..8333757
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.getrandom-0.2.3.bazel
@@ -0,0 +1,96 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "mod" with type "bench" omitted
+
+rust_library(
+    name = "getrandom",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=getrandom",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__cfg_if__1_0_0//:cfg_if",
+    ] + selects.with_or({
+        # cfg(target_os = "wasi")
+        (
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            "@rules_rust_util_import__wasi__0_10_2_wasi_snapshot_preview1//:wasi",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_util_import__libc__0_2_112//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "custom" with type "test" omitted
+
+# Unsupported target "normal" with type "test" omitted
+
+# Unsupported target "rdrand" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..5542226
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=lazy_static",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.libc-0.2.112.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.libc-0.2.112.bazel
new file mode 100644
index 0000000..2d8a3fe
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.libc-0.2.112.bazel
@@ -0,0 +1,86 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libc_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.112",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=libc",
+        "manual",
+    ],
+    version = "0.2.112",
+    # buildifier: leave-alone
+    deps = [
+        ":libc_build_script",
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.log-0.4.14.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..02efe53
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.log-0.4.14.bazel
@@ -0,0 +1,93 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "log_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "value" with type "bench" omitted
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=log",
+        "manual",
+    ],
+    version = "0.4.14",
+    # buildifier: leave-alone
+    deps = [
+        ":log_build_script",
+        "@rules_rust_util_import__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
+
+# Unsupported target "macros" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..c8e37c3
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,90 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "memchr_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+        "use_std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "memchr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=memchr",
+        "manual",
+    ],
+    version = "2.4.1",
+    # buildifier: leave-alone
+    deps = [
+        ":memchr_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.proc-macro2-1.0.33.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.proc-macro2-1.0.33.bazel
new file mode 100644
index 0000000..0e479f2
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.proc-macro2-1.0.33.bazel
@@ -0,0 +1,99 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "proc_macro2_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.33",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=proc-macro2",
+        "manual",
+    ],
+    version = "1.0.33",
+    # buildifier: leave-alone
+    deps = [
+        ":proc_macro2_build_script",
+        "@rules_rust_util_import__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "comments" with type "test" omitted
+
+# Unsupported target "features" with type "test" omitted
+
+# Unsupported target "marker" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.quickcheck-1.0.3.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.quickcheck-1.0.3.bazel
new file mode 100644
index 0000000..a9db2b4
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.quickcheck-1.0.3.bazel
@@ -0,0 +1,74 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "btree_set_range" with type "example" omitted
+
+# Unsupported target "out_of_bounds" with type "example" omitted
+
+# Unsupported target "reverse" with type "example" omitted
+
+# Unsupported target "reverse_single" with type "example" omitted
+
+# Unsupported target "sieve" with type "example" omitted
+
+# Unsupported target "sort" with type "example" omitted
+
+rust_library(
+    name = "quickcheck",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "env_logger",
+        "log",
+        "regex",
+        "use_logging",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=quickcheck",
+        "manual",
+    ],
+    version = "1.0.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__env_logger__0_8_4//:env_logger",
+        "@rules_rust_util_import__log__0_4_14//:log",
+        "@rules_rust_util_import__rand__0_8_4//:rand",
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.quote-1.0.10.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.quote-1.0.10.bazel
new file mode 100644
index 0000000..040d8cb
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.quote-1.0.10.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "quote",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=quote",
+        "manual",
+    ],
+    version = "1.0.10",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__proc_macro2__1_0_33//:proc_macro2",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.rand-0.8.4.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.rand-0.8.4.bazel
new file mode 100644
index 0000000..ebbb9e3
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.rand-0.8.4.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "getrandom",
+        "small_rng",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=rand",
+        "manual",
+    ],
+    version = "0.8.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__rand_core__0_6_3//:rand_core",
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.rand_core-0.6.3.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.rand_core-0.6.3.bazel
new file mode 100644
index 0000000..1cc93d3
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.rand_core-0.6.3.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand_core",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "getrandom",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=rand_core",
+        "manual",
+    ],
+    version = "0.6.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__getrandom__0_2_3//:getrandom",
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.regex-1.4.6.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.regex-1.4.6.bazel
new file mode 100644
index 0000000..0957c94
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.regex-1.4.6.bazel
@@ -0,0 +1,95 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "shootout-regex-dna" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-bytes" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-cheat" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-replace" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single-cheat" with type "example" omitted
+
+rust_library(
+    name = "regex",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "aho-corasick",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=regex",
+        "manual",
+    ],
+    version = "1.4.6",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_util_import__aho_corasick__0_7_15//:aho_corasick",
+        "@rules_rust_util_import__memchr__2_4_1//:memchr",
+        "@rules_rust_util_import__regex_syntax__0_6_25//:regex_syntax",
+    ],
+)
+
+# Unsupported target "backtrack" with type "test" omitted
+
+# Unsupported target "backtrack-bytes" with type "test" omitted
+
+# Unsupported target "backtrack-utf8bytes" with type "test" omitted
+
+# Unsupported target "crates-regex" with type "test" omitted
+
+# Unsupported target "default" with type "test" omitted
+
+# Unsupported target "default-bytes" with type "test" omitted
+
+# Unsupported target "nfa" with type "test" omitted
+
+# Unsupported target "nfa-bytes" with type "test" omitted
+
+# Unsupported target "nfa-utf8bytes" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.regex-syntax-0.6.25.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.regex-syntax-0.6.25.bazel
new file mode 100644
index 0000000..71324e7
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.regex-syntax-0.6.25.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "regex_syntax",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=regex-syntax",
+        "manual",
+    ],
+    version = "0.6.25",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.syn-1.0.82.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.syn-1.0.82.bazel
new file mode 100644
index 0000000..8031e00
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.syn-1.0.82.bazel
@@ -0,0 +1,157 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "syn_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.82",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "file" with type "bench" omitted
+
+# Unsupported target "rust" with type "bench" omitted
+
+rust_library(
+    name = "syn",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=syn",
+        "manual",
+    ],
+    version = "1.0.82",
+    # buildifier: leave-alone
+    deps = [
+        ":syn_build_script",
+        "@rules_rust_util_import__proc_macro2__1_0_33//:proc_macro2",
+        "@rules_rust_util_import__quote__1_0_10//:quote",
+        "@rules_rust_util_import__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "test_asyncness" with type "test" omitted
+
+# Unsupported target "test_attribute" with type "test" omitted
+
+# Unsupported target "test_derive_input" with type "test" omitted
+
+# Unsupported target "test_expr" with type "test" omitted
+
+# Unsupported target "test_generics" with type "test" omitted
+
+# Unsupported target "test_grouping" with type "test" omitted
+
+# Unsupported target "test_ident" with type "test" omitted
+
+# Unsupported target "test_item" with type "test" omitted
+
+# Unsupported target "test_iterators" with type "test" omitted
+
+# Unsupported target "test_lit" with type "test" omitted
+
+# Unsupported target "test_meta" with type "test" omitted
+
+# Unsupported target "test_parse_buffer" with type "test" omitted
+
+# Unsupported target "test_parse_stream" with type "test" omitted
+
+# Unsupported target "test_pat" with type "test" omitted
+
+# Unsupported target "test_path" with type "test" omitted
+
+# Unsupported target "test_precedence" with type "test" omitted
+
+# Unsupported target "test_receiver" with type "test" omitted
+
+# Unsupported target "test_round_trip" with type "test" omitted
+
+# Unsupported target "test_shebang" with type "test" omitted
+
+# Unsupported target "test_should_parse" with type "test" omitted
+
+# Unsupported target "test_size" with type "test" omitted
+
+# Unsupported target "test_stmt" with type "test" omitted
+
+# Unsupported target "test_token_trees" with type "test" omitted
+
+# Unsupported target "test_ty" with type "test" omitted
+
+# Unsupported target "test_visibility" with type "test" omitted
+
+# Unsupported target "zzz_stable" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..a62237c
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "xid" with type "bench" omitted
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=unicode-xid",
+        "manual",
+    ],
+    version = "0.2.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "exhaustive_tests" with type "test" omitted
diff --git a/third_party/rules_rust/util/import/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel b/third_party/rules_rust/util/import/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
new file mode 100644
index 0000000..f4229fe
--- /dev/null
+++ b/third_party/rules_rust/util/import/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//util/import/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR (Apache-2.0 OR MIT)"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "crate-name=wasi",
+        "manual",
+    ],
+    version = "0.10.2+wasi-snapshot-preview1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/util/label/BUILD.bazel b/third_party/rules_rust/util/label/BUILD.bazel
new file mode 100644
index 0000000..405006d
--- /dev/null
+++ b/third_party/rules_rust/util/label/BUILD.bazel
@@ -0,0 +1,16 @@
+load("//rust:defs.bzl", "rust_library", "rust_test")
+
+rust_library(
+    name = "label",
+    srcs = [
+        "label.rs",
+        "label_error.rs",
+    ],
+    edition = "2018",
+    visibility = ["//:__subpackages__"],
+)
+
+rust_test(
+    name = "label_test",
+    crate = ":label",
+)
diff --git a/third_party/rules_rust/util/label/label.rs b/third_party/rules_rust/util/label/label.rs
new file mode 100644
index 0000000..22d2bb4
--- /dev/null
+++ b/third_party/rules_rust/util/label/label.rs
@@ -0,0 +1,426 @@
+//! Bazel label parsing library.
+//!
+//! USAGE: `label::analyze("//foo/bar:baz")
+mod label_error;
+use label_error::LabelError;
+
+/// Parse and analyze given str.
+///
+/// TODO: validate . and .. in target name
+/// TODO: validate used characters in target name
+pub fn analyze(input: &'_ str) -> Result<Label<'_>> {
+    let label = input;
+    let (input, repository_name) = consume_repository_name(input, label)?;
+    let (input, package_name) = consume_package_name(input, label)?;
+    let name = consume_name(input, label)?;
+    let name = match (package_name, name) {
+        (None, None) => {
+            return Err(LabelError(err(
+                label,
+                "labels must have a package and/or a name.",
+            )))
+        }
+        (Some(package_name), None) => name_from_package(package_name),
+        (_, Some(name)) => name,
+    };
+    Ok(Label::new(repository_name, package_name, name))
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Label<'s> {
+    pub repository_name: Option<&'s str>,
+    pub package_name: Option<&'s str>,
+    pub name: &'s str,
+}
+
+type Result<T, E = LabelError> = core::result::Result<T, E>;
+
+impl<'s> Label<'s> {
+    fn new(
+        repository_name: Option<&'s str>,
+        package_name: Option<&'s str>,
+        name: &'s str,
+    ) -> Label<'s> {
+        Label {
+            repository_name,
+            package_name,
+            name,
+        }
+    }
+
+    pub fn packages(&self) -> Vec<&'s str> {
+        match self.package_name {
+            Some(name) => name.split('/').collect(),
+            None => vec![],
+        }
+    }
+}
+
+fn err<'s>(label: &'s str, msg: &'s str) -> String {
+    let mut err_msg = label.to_string();
+    err_msg.push_str(" must be a legal label; ");
+    err_msg.push_str(msg);
+    err_msg
+}
+
+fn consume_repository_name<'s>(
+    input: &'s str,
+    label: &'s str,
+) -> Result<(&'s str, Option<&'s str>)> {
+    if !input.starts_with('@') {
+        return Ok((input, None));
+    }
+
+    let slash_pos = input
+        .find("//")
+        .ok_or_else(|| err(label, "labels with repository must contain //."))?;
+    let repository_name = &input[1..slash_pos];
+    if repository_name.is_empty() {
+        return Ok((&input[1..], None));
+    }
+    if !repository_name
+        .chars()
+        .next()
+        .unwrap()
+        .is_ascii_alphabetic()
+    {
+        return Err(LabelError(err(
+            label,
+            "workspace names must start with a letter.",
+        )));
+    }
+    if !repository_name
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.')
+    {
+        return Err(LabelError(err(
+            label,
+            "workspace names \
+                may contain only A-Z, a-z, 0-9, '-', '_', and '.'.",
+        )));
+    }
+    Ok((&input[slash_pos..], Some(repository_name)))
+}
+
+fn consume_package_name<'s>(input: &'s str, label: &'s str) -> Result<(&'s str, Option<&'s str>)> {
+    let is_absolute = match input.rfind("//") {
+        None => false,
+        Some(0) => true,
+        Some(_) => {
+            return Err(LabelError(err(
+                label,
+                "'//' cannot appear in the middle of the label.",
+            )));
+        }
+    };
+
+    let (package_name, rest) = match (is_absolute, input.find(':')) {
+        (false, colon_pos) if colon_pos.map_or(true, |pos| pos != 0) => {
+            return Err(LabelError(err(
+                label,
+                "relative packages are not permitted.",
+            )));
+        }
+        (_, colon_pos) => {
+            let (input, colon_pos) = if is_absolute {
+                (&input[2..], colon_pos.map(|cp| cp - 2))
+            } else {
+                (input, colon_pos)
+            };
+            match colon_pos {
+                Some(colon_pos) => (&input[0..colon_pos], &input[colon_pos..]),
+                None => (input, ""),
+            }
+        }
+    };
+
+    if package_name.is_empty() {
+        return Ok((rest, None));
+    }
+
+    if !package_name.chars().all(|c| {
+        c.is_ascii_alphanumeric()
+            || c == '/'
+            || c == '-'
+            || c == '.'
+            || c == ' '
+            || c == '$'
+            || c == '('
+            || c == ')'
+            || c == '_'
+    }) {
+        return Err(LabelError(err(
+            label,
+            "package names may contain only A-Z, \
+        a-z, 0-9, '/', '-', '.', ' ', '$', '(', ')' and '_'.",
+        )));
+    }
+    if package_name.ends_with('/') {
+        return Err(LabelError(err(
+            label,
+            "package names may not end with '/'.",
+        )));
+    }
+
+    if rest.is_empty() && is_absolute {
+        // This label doesn't contain the target name, we have to use
+        // last segment of the package name as target name.
+        return Ok((
+            match package_name.rfind('/') {
+                Some(pos) => &package_name[pos..],
+                None => package_name,
+            },
+            Some(package_name),
+        ));
+    }
+
+    Ok((rest, Some(package_name)))
+}
+
+fn consume_name<'s>(input: &'s str, label: &'s str) -> Result<Option<&'s str>> {
+    if input.is_empty() {
+        return Ok(None);
+    }
+    if input == ":" {
+        return Err(LabelError(err(label, "empty target name.")));
+    }
+    let name = input
+        .strip_prefix(':')
+        .or_else(|| input.strip_prefix('/'))
+        .unwrap_or(input);
+    if name.starts_with('/') {
+        return Err(LabelError(err(
+            label,
+            "target names may not start with '/'.",
+        )));
+    }
+    Ok(Some(name))
+}
+
+fn name_from_package(package_name: &str) -> &str {
+    package_name
+        .rsplit_once('/')
+        .map(|tup| tup.1)
+        .unwrap_or(package_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        assert_eq!(
+            Label::new(Some("repo"), Some("foo/bar"), "baz"),
+            Label {
+                repository_name: Some("repo"),
+                package_name: Some("foo/bar"),
+                name: "baz",
+            }
+        );
+    }
+
+    #[test]
+    fn test_repository_name_parsing() -> Result<()> {
+        assert_eq!(analyze("@repo//:foo")?.repository_name, Some("repo"));
+        assert_eq!(analyze("@//:foo")?.repository_name, None);
+        assert_eq!(analyze("//:foo")?.repository_name, None);
+        assert_eq!(analyze(":foo")?.repository_name, None);
+
+        assert_eq!(analyze("@repo//foo/bar")?.repository_name, Some("repo"));
+        assert_eq!(analyze("@//foo/bar")?.repository_name, None);
+        assert_eq!(analyze("//foo/bar")?.repository_name, None);
+        assert_eq!(
+            analyze("foo/bar"),
+            Err(LabelError(
+                "foo/bar must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        assert_eq!(analyze("@repo//foo")?.repository_name, Some("repo"));
+        assert_eq!(analyze("@//foo")?.repository_name, None);
+        assert_eq!(analyze("//foo")?.repository_name, None);
+        assert_eq!(
+            analyze("foo"),
+            Err(LabelError(
+                "foo must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        assert_eq!(
+            analyze("@foo:bar"),
+            Err(LabelError(
+                "@foo:bar must be a legal label; labels with repository must contain //."
+                    .to_string()
+            ))
+        );
+
+        assert_eq!(
+            analyze("@AZab0123456789_-.//:foo")?.repository_name,
+            Some("AZab0123456789_-.")
+        );
+        assert_eq!(
+            analyze("@42//:baz"),
+            Err(LabelError(
+                "@42//:baz must be a legal label; workspace names must \
+            start with a letter."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("@foo#//:baz"),
+            Err(LabelError(
+                "@foo#//:baz must be a legal label; workspace names \
+            may contain only A-Z, a-z, 0-9, '-', '_', and '.'."
+                    .to_string()
+            ))
+        );
+        Ok(())
+    }
+    #[test]
+    fn test_package_name_parsing() -> Result<()> {
+        assert_eq!(analyze("//:baz/qux")?.package_name, None);
+        assert_eq!(analyze(":baz/qux")?.package_name, None);
+
+        assert_eq!(analyze("//foo:baz/qux")?.package_name, Some("foo"));
+        assert_eq!(analyze("//foo/bar:baz/qux")?.package_name, Some("foo/bar"));
+        assert_eq!(
+            analyze("foo:baz/qux"),
+            Err(LabelError(
+                "foo:baz/qux must be a legal label; relative packages are not permitted."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("foo/bar:baz/qux"),
+            Err(LabelError(
+                "foo/bar:baz/qux must be a legal label; relative packages are not permitted."
+                    .to_string()
+            ))
+        );
+
+        assert_eq!(analyze("//foo")?.package_name, Some("foo"));
+
+        assert_eq!(
+            analyze("foo//bar"),
+            Err(LabelError(
+                "foo//bar must be a legal label; '//' cannot appear in the middle of the label."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("//foo//bar"),
+            Err(LabelError(
+                "//foo//bar must be a legal label; '//' cannot appear in the middle of the label."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("foo//bar:baz"),
+            Err(LabelError(
+                "foo//bar:baz must be a legal label; '//' cannot appear in the middle of the label."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("//foo//bar:baz"),
+            Err(LabelError(
+                "//foo//bar:baz must be a legal label; '//' cannot appear in the middle of the label."
+                    .to_string()
+            ))
+        );
+
+        assert_eq!(
+            analyze("//azAZ09/-. $()_:baz")?.package_name,
+            Some("azAZ09/-. $()_")
+        );
+        assert_eq!(
+            analyze("//bar#:baz"),
+            Err(LabelError(
+                "//bar#:baz must be a legal label; package names may contain only A-Z, \
+                a-z, 0-9, '/', '-', '.', ' ', '$', '(', ')' and '_'."
+                    .to_string()
+            ))
+        );
+        assert_eq!(
+            analyze("//bar/:baz"),
+            Err(LabelError(
+                "//bar/:baz must be a legal label; package names may not end with '/'.".to_string()
+            ))
+        );
+
+        assert_eq!(analyze("@repo//foo/bar")?.package_name, Some("foo/bar"));
+        assert_eq!(analyze("//foo/bar")?.package_name, Some("foo/bar"));
+        assert_eq!(
+            analyze("foo/bar"),
+            Err(LabelError(
+                "foo/bar must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        assert_eq!(analyze("@repo//foo")?.package_name, Some("foo"));
+        assert_eq!(analyze("//foo")?.package_name, Some("foo"));
+        assert_eq!(
+            analyze("foo"),
+            Err(LabelError(
+                "foo must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_name_parsing() -> Result<()> {
+        assert_eq!(analyze("//foo:baz")?.name, "baz");
+        assert_eq!(analyze("//foo:baz/qux")?.name, "baz/qux");
+
+        assert_eq!(
+            analyze("//bar:"),
+            Err(LabelError(
+                "//bar: must be a legal label; empty target name.".to_string()
+            ))
+        );
+        assert_eq!(analyze("//foo")?.name, "foo");
+
+        assert_eq!(
+            analyze("//bar:/foo"),
+            Err(LabelError(
+                "//bar:/foo must be a legal label; target names may not start with '/'."
+                    .to_string()
+            ))
+        );
+
+        assert_eq!(analyze("@repo//foo/bar")?.name, "bar");
+        assert_eq!(analyze("//foo/bar")?.name, "bar");
+        assert_eq!(
+            analyze("foo/bar"),
+            Err(LabelError(
+                "foo/bar must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        assert_eq!(analyze("@repo//foo")?.name, "foo");
+        assert_eq!(analyze("//foo")?.name, "foo");
+        assert_eq!(
+            analyze("foo"),
+            Err(LabelError(
+                "foo must be a legal label; relative packages are not permitted.".to_string()
+            ))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_packages() -> Result<()> {
+        assert_eq!(analyze("@repo//:baz")?.packages(), Vec::<&str>::new());
+        assert_eq!(analyze("@repo//foo:baz")?.packages(), vec!["foo"]);
+        assert_eq!(
+            analyze("@repo//foo/bar:baz")?.packages(),
+            vec!["foo", "bar"]
+        );
+
+        Ok(())
+    }
+}
diff --git a/third_party/rules_rust/util/label/label_error.rs b/third_party/rules_rust/util/label/label_error.rs
new file mode 100644
index 0000000..b1d7199
--- /dev/null
+++ b/third_party/rules_rust/util/label/label_error.rs
@@ -0,0 +1,20 @@
+#[derive(Debug, PartialEq)]
+pub struct LabelError(pub String);
+
+impl std::fmt::Display for LabelError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::error::Error for LabelError {
+    fn description(&self) -> &str {
+        &self.0
+    }
+}
+
+impl From<String> for LabelError {
+    fn from(msg: String) -> Self {
+        Self(msg)
+    }
+}
diff --git a/third_party/rules_rust/util/process_wrapper/BUILD.bazel b/third_party/rules_rust/util/process_wrapper/BUILD.bazel
new file mode 100644
index 0000000..c26d9a6
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/BUILD.bazel
@@ -0,0 +1,45 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("//rust:defs.bzl", "rust_binary", "rust_test")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:transitions.bzl", "without_process_wrapper")
+
+alias(
+    name = "process_wrapper",
+    actual = select({
+        # This will never get used, it's only here to break the circular dependency to allow building process_wrapper
+        ":use_fake_process_wrapper": ":process_wrapper_fake",
+        "//conditions:default": ":process_wrapper_impl",
+    }),
+    visibility = ["//visibility:public"],
+)
+
+cc_binary(
+    name = "process_wrapper_fake",
+    srcs = ["fake.cc"],
+)
+
+config_setting(
+    name = "use_fake_process_wrapper",
+    flag_values = {
+        "//rust/settings:use_process_wrapper": "False",
+    },
+)
+
+# Changing the name of this rule requires a corresponding
+# change in //rust/private/rustc.bzl:925
+without_process_wrapper(
+    name = "process_wrapper_impl",
+    target = ":process_wrapper_bin",
+    visibility = ["//visibility:public"],
+)
+
+rust_binary(
+    name = "process_wrapper_bin",
+    srcs = glob(["*.rs"]),
+)
+
+rust_test(
+    name = "process_wrapper_test",
+    crate = ":process_wrapper_bin",
+)
diff --git a/third_party/rules_rust/util/process_wrapper/fake.cc b/third_party/rules_rust/util/process_wrapper/fake.cc
new file mode 100644
index 0000000..a0b6869
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/fake.cc
@@ -0,0 +1,4 @@
+int main() {
+    // Noop on purpose.
+    return 0;
+}
\ No newline at end of file
diff --git a/third_party/rules_rust/util/process_wrapper/flags.rs b/third_party/rules_rust/util/process_wrapper/flags.rs
new file mode 100644
index 0000000..d3d6fe5
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/flags.rs
@@ -0,0 +1,276 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+use std::collections::{BTreeMap, HashSet};
+use std::error::Error;
+use std::fmt;
+use std::fmt::Write;
+use std::iter::Peekable;
+use std::mem::take;
+
+#[derive(Debug, Clone)]
+pub(crate) enum FlagParseError {
+    UnknownFlag(String),
+    ValueMissing(String),
+    ProvidedMultipleTimes(String),
+    ProgramNameMissing,
+}
+
+impl fmt::Display for FlagParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::UnknownFlag(ref flag) => write!(f, "unknown flag \"{}\"", flag),
+            Self::ValueMissing(ref flag) => write!(f, "flag \"{}\" missing parameter(s)", flag),
+            Self::ProvidedMultipleTimes(ref flag) => {
+                write!(f, "flag \"{}\" can only appear once", flag)
+            }
+            Self::ProgramNameMissing => {
+                write!(f, "program name (argv[0]) missing")
+            }
+        }
+    }
+}
+impl Error for FlagParseError {}
+
+struct FlagDef<'a, T> {
+    name: String,
+    help: String,
+    output_storage: &'a mut Option<T>,
+}
+
+impl<'a, T> fmt::Display for FlagDef<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}\t{}", self.name, self.help)
+    }
+}
+
+impl<'a, T> fmt::Debug for FlagDef<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("FlagDef")
+            .field("name", &self.name)
+            .field("help", &self.help)
+            .finish()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Flags<'a> {
+    single: BTreeMap<String, FlagDef<'a, String>>,
+    repeated: BTreeMap<String, FlagDef<'a, Vec<String>>>,
+}
+
+#[derive(Debug)]
+pub(crate) enum ParseOutcome {
+    Help(String),
+    Parsed(Vec<String>),
+}
+
+impl<'a> Flags<'a> {
+    pub(crate) fn new() -> Flags<'a> {
+        Flags {
+            single: BTreeMap::new(),
+            repeated: BTreeMap::new(),
+        }
+    }
+
+    pub(crate) fn define_flag(
+        &mut self,
+        name: impl Into<String>,
+        help: impl Into<String>,
+        output_storage: &'a mut Option<String>,
+    ) {
+        let name = name.into();
+        if self.repeated.contains_key(&name) {
+            panic!("argument \"{}\" already defined as repeated flag", name)
+        }
+        self.single.insert(
+            name.clone(),
+            FlagDef::<'a, String> {
+                name,
+                help: help.into(),
+                output_storage,
+            },
+        );
+    }
+
+    pub(crate) fn define_repeated_flag(
+        &mut self,
+        name: impl Into<String>,
+        help: impl Into<String>,
+        output_storage: &'a mut Option<Vec<String>>,
+    ) {
+        let name = name.into();
+        if self.single.contains_key(&name) {
+            panic!("argument \"{}\" already defined as flag", name)
+        }
+        self.repeated.insert(
+            name.clone(),
+            FlagDef::<'a, Vec<String>> {
+                name,
+                help: help.into(),
+                output_storage,
+            },
+        );
+    }
+
+    fn help(&self, program_name: String) -> String {
+        let single = self.single.values().map(|fd| fd.to_string());
+        let repeated = self.repeated.values().map(|fd| fd.to_string());
+        let mut all: Vec<String> = single.chain(repeated).collect();
+        all.sort();
+
+        let mut help_text = String::new();
+        writeln!(
+            &mut help_text,
+            "Help for {}: [options] -- [extra arguments]",
+            program_name
+        )
+        .unwrap();
+        for line in all {
+            writeln!(&mut help_text, "\t{}", line).unwrap();
+        }
+        help_text
+    }
+
+    pub(crate) fn parse(mut self, argv: Vec<String>) -> Result<ParseOutcome, FlagParseError> {
+        let mut argv_iter = argv.into_iter().peekable();
+        let program_name = argv_iter.next().ok_or(FlagParseError::ProgramNameMissing)?;
+
+        // To check if a non-repeated flag has been set already.
+        let mut seen_single_flags = HashSet::<String>::new();
+
+        while let Some(flag) = argv_iter.next() {
+            if flag == "--help" {
+                return Ok(ParseOutcome::Help(self.help(program_name)));
+            }
+            if !flag.starts_with("--") {
+                return Err(FlagParseError::UnknownFlag(flag));
+            }
+            let mut args = consume_args(&flag, &mut argv_iter);
+            if flag == "--" {
+                return Ok(ParseOutcome::Parsed(args));
+            }
+            if args.is_empty() {
+                return Err(FlagParseError::ValueMissing(flag.clone()));
+            }
+            if let Some(flag_def) = self.single.get_mut(&flag) {
+                if args.len() > 1 || seen_single_flags.contains(&flag) {
+                    return Err(FlagParseError::ProvidedMultipleTimes(flag.clone()));
+                }
+                let arg = args.first_mut().unwrap();
+                seen_single_flags.insert(flag);
+                *flag_def.output_storage = Some(take(arg));
+                continue;
+            }
+            if let Some(flag_def) = self.repeated.get_mut(&flag) {
+                flag_def
+                    .output_storage
+                    .get_or_insert_with(Vec::new)
+                    .append(&mut args);
+                continue;
+            }
+            return Err(FlagParseError::UnknownFlag(flag));
+        }
+        Ok(ParseOutcome::Parsed(vec![]))
+    }
+}
+
+fn consume_args<I: Iterator<Item = String>>(
+    flag: &str,
+    argv_iter: &mut Peekable<I>,
+) -> Vec<String> {
+    if flag == "--" {
+        // If we have found --, the rest of the iterator is just returned as-is.
+        argv_iter.collect()
+    } else {
+        let mut args = vec![];
+        while let Some(arg) = argv_iter.next_if(|s| !s.starts_with("--")) {
+            args.push(arg);
+        }
+        args
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn args(args: &[&str]) -> Vec<String> {
+        ["foo"].iter().chain(args).map(|&s| s.to_owned()).collect()
+    }
+
+    #[test]
+    fn test_flag_help() {
+        let mut bar = None;
+        let mut parser = Flags::new();
+        parser.define_flag("--bar", "bar help", &mut bar);
+        let result = parser.parse(args(&["--help"])).unwrap();
+        if let ParseOutcome::Help(h) = result {
+            assert!(h.contains("Help for foo"));
+            assert!(h.contains("--bar\tbar help"));
+        } else {
+            panic!("expected that --help would invoke help, instead parsed arguments")
+        }
+    }
+
+    #[test]
+    fn test_flag_single_repeated() {
+        let mut bar = None;
+        let mut parser = Flags::new();
+        parser.define_flag("--bar", "bar help", &mut bar);
+        let result = parser.parse(args(&["--bar", "aa", "bb"]));
+        if let Err(FlagParseError::ProvidedMultipleTimes(f)) = result {
+            assert_eq!(f, "--bar");
+        } else {
+            panic!("expected error, got {:?}", result)
+        }
+        let mut parser = Flags::new();
+        parser.define_flag("--bar", "bar help", &mut bar);
+        let result = parser.parse(args(&["--bar", "aa", "--bar", "bb"]));
+        if let Err(FlagParseError::ProvidedMultipleTimes(f)) = result {
+            assert_eq!(f, "--bar");
+        } else {
+            panic!("expected error, got {:?}", result)
+        }
+    }
+
+    #[test]
+    fn test_repeated_flags() {
+        // Test case 1) --bar something something_else should work as a repeated flag.
+        let mut bar = None;
+        let mut parser = Flags::new();
+        parser.define_repeated_flag("--bar", "bar help", &mut bar);
+        let result = parser.parse(args(&["--bar", "aa", "bb"])).unwrap();
+        assert!(matches!(result, ParseOutcome::Parsed(_)));
+        assert_eq!(bar, Some(vec!["aa".to_owned(), "bb".to_owned()]));
+        // Test case 2) --bar something --bar something_else should also work as a repeated flag.
+        bar = None;
+        let mut parser = Flags::new();
+        parser.define_repeated_flag("--bar", "bar help", &mut bar);
+        let result = parser.parse(args(&["--bar", "aa", "--bar", "bb"])).unwrap();
+        assert!(matches!(result, ParseOutcome::Parsed(_)));
+        assert_eq!(bar, Some(vec!["aa".to_owned(), "bb".to_owned()]));
+    }
+
+    #[test]
+    fn test_extra_args() {
+        let parser = Flags::new();
+        let result = parser.parse(args(&["--", "bb"])).unwrap();
+        if let ParseOutcome::Parsed(got) = result {
+            assert_eq!(got, vec!["bb".to_owned()])
+        } else {
+            panic!("expected correct parsing, got {:?}", result)
+        }
+    }
+}
diff --git a/third_party/rules_rust/util/process_wrapper/main.rs b/third_party/rules_rust/util/process_wrapper/main.rs
new file mode 100644
index 0000000..41140a3
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/main.rs
@@ -0,0 +1,79 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+mod flags;
+mod options;
+mod util;
+
+use std::fs::{copy, OpenOptions};
+use std::process::{exit, Command, Stdio};
+
+use crate::options::options;
+
+fn main() {
+    let opts = match options() {
+        Err(err) => panic!("process wrapper error: {}", err),
+        Ok(v) => v,
+    };
+    let stdout = if let Some(stdout_file) = opts.stdout_file {
+        OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(stdout_file)
+            .expect("process wrapper error: unable to open stdout file")
+            .into()
+    } else {
+        Stdio::inherit()
+    };
+    let stderr = if let Some(stderr_file) = opts.stderr_file {
+        OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(stderr_file)
+            .expect("process wrapper error: unable to open stderr file")
+            .into()
+    } else {
+        Stdio::inherit()
+    };
+    let status = Command::new(opts.executable)
+        .args(opts.child_arguments)
+        .env_clear()
+        .envs(opts.child_environment)
+        .stdout(stdout)
+        .stderr(stderr)
+        .status()
+        .expect("process wrapper error: failed to spawn child process");
+
+    if status.success() {
+        if let Some(tf) = opts.touch_file {
+            OpenOptions::new()
+                .create(true)
+                .write(true)
+                .open(tf)
+                .expect("process wrapper error: failed to create touch file");
+        }
+        if let Some((copy_source, copy_dest)) = opts.copy_output {
+            copy(&copy_source, &copy_dest).unwrap_or_else(|_| {
+                panic!(
+                    "process wrapper error: failed to copy {} into {}",
+                    copy_source, copy_dest
+                )
+            });
+        }
+    }
+
+    exit(status.code().unwrap())
+}
diff --git a/third_party/rules_rust/util/process_wrapper/options.rs b/third_party/rules_rust/util/process_wrapper/options.rs
new file mode 100644
index 0000000..24bba9f
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/options.rs
@@ -0,0 +1,226 @@
+use std::collections::HashMap;
+use std::env;
+use std::fmt;
+use std::process::exit;
+
+use crate::flags::{FlagParseError, Flags, ParseOutcome};
+use crate::util::*;
+
+#[derive(Debug)]
+pub(crate) enum OptionError {
+    FlagError(FlagParseError),
+    Generic(String),
+}
+
+impl fmt::Display for OptionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::FlagError(e) => write!(f, "error parsing flags: {}", e),
+            Self::Generic(s) => write!(f, "{}", s),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Options {
+    // Contains the path to the child executable
+    pub(crate) executable: String,
+    // Contains arguments for the child process fetched from files.
+    pub(crate) child_arguments: Vec<String>,
+    // Contains environment variables for the child process fetched from files.
+    pub(crate) child_environment: HashMap<String, String>,
+    // If set, create the specified file after the child process successfully
+    // terminated its execution.
+    pub(crate) touch_file: Option<String>,
+    // If set to (source, dest) copies the source file to dest.
+    pub(crate) copy_output: Option<(String, String)>,
+    // If set, redirects the child process stdout to this file.
+    pub(crate) stdout_file: Option<String>,
+    // If set, redirects the child process stderr to this file.
+    pub(crate) stderr_file: Option<String>,
+}
+
+pub(crate) fn options() -> Result<Options, OptionError> {
+    // Process argument list until -- is encountered.
+    // Everything after is sent to the child process.
+    let mut subst_mapping_raw = None;
+    let mut volatile_status_file_raw = None;
+    let mut env_file_raw = None;
+    let mut arg_file_raw = None;
+    let mut touch_file = None;
+    let mut copy_output_raw = None;
+    let mut stdout_file = None;
+    let mut stderr_file = None;
+    let mut flags = Flags::new();
+    flags.define_repeated_flag("--subst", "", &mut subst_mapping_raw);
+    flags.define_flag("--volatile-status-file", "", &mut volatile_status_file_raw);
+    flags.define_repeated_flag(
+        "--env-file",
+        "File(s) containing environment variables to pass to the child process.",
+        &mut env_file_raw,
+    );
+    flags.define_repeated_flag(
+        "--arg-file",
+        "File(s) containing command line arguments to pass to the child process.",
+        &mut arg_file_raw,
+    );
+    flags.define_flag(
+        "--touch-file",
+        "Create this file after the child process runs successfully.",
+        &mut touch_file,
+    );
+    flags.define_repeated_flag("--copy-output", "", &mut copy_output_raw);
+    flags.define_flag(
+        "--stdout-file",
+        "Redirect subprocess stdout in this file.",
+        &mut stdout_file,
+    );
+    flags.define_flag(
+        "--stderr-file",
+        "Redirect subprocess stderr in this file.",
+        &mut stderr_file,
+    );
+
+    let mut child_args = match flags
+        .parse(env::args().collect())
+        .map_err(OptionError::FlagError)?
+    {
+        ParseOutcome::Help(help) => {
+            eprintln!("{}", help);
+            exit(0);
+        }
+        ParseOutcome::Parsed(p) => p,
+    };
+    let current_dir = std::env::current_dir()
+        .map_err(|e| OptionError::Generic(format!("failed to get current directory: {}", e)))?
+        .to_str()
+        .ok_or_else(|| OptionError::Generic("current directory not utf-8".to_owned()))?
+        .to_owned();
+    let subst_mappings = subst_mapping_raw
+        .unwrap_or_default()
+        .into_iter()
+        .map(|arg| {
+            let (key, val) = arg.split_once('=').ok_or_else(|| {
+                OptionError::Generic(format!("empty key for substitution '{}'", arg))
+            })?;
+            let v = if val == "${pwd}" {
+                current_dir.as_str()
+            } else {
+                val
+            }
+            .to_owned();
+            Ok((key.to_owned(), v))
+        })
+        .collect::<Result<Vec<(String, String)>, OptionError>>()?;
+    let stamp_mappings =
+        volatile_status_file_raw.map_or_else(Vec::new, |s| read_stamp_status_to_array(s).unwrap());
+
+    let environment_file_block = env_from_files(env_file_raw.unwrap_or_default())?;
+    let mut file_arguments = args_from_file(arg_file_raw.unwrap_or_default())?;
+    // Process --copy-output
+    let copy_output = copy_output_raw
+        .map(|co| {
+            if co.len() != 2 {
+                return Err(OptionError::Generic(format!(
+                    "\"--copy-output\" needs exactly 2 parameters, {} provided",
+                    co.len()
+                )));
+            }
+            let copy_source = &co[0];
+            let copy_dest = &co[1];
+            if copy_source == copy_dest {
+                return Err(OptionError::Generic(format!(
+                    "\"--copy-output\" source ({}) and dest ({}) need to be different.",
+                    copy_source, copy_dest
+                )));
+            }
+            Ok((copy_source.to_owned(), copy_dest.to_owned()))
+        })
+        .transpose()?;
+
+    // Prepare the environment variables, unifying those read from files with the ones
+    // of the current process.
+    let vars = environment_block(environment_file_block, &stamp_mappings, &subst_mappings);
+    // Append all the arguments fetched from files to those provided via command line.
+    child_args.append(&mut file_arguments);
+    let child_args = prepare_args(child_args, &subst_mappings);
+    // Split the executable path from the rest of the arguments.
+    let (exec_path, args) = child_args.split_first().ok_or_else(|| {
+        OptionError::Generic(
+            "at least one argument after -- is required (the child process path)".to_owned(),
+        )
+    })?;
+
+    Ok(Options {
+        executable: exec_path.to_owned(),
+        child_arguments: args.to_vec(),
+        child_environment: vars,
+        touch_file,
+        copy_output,
+        stdout_file,
+        stderr_file,
+    })
+}
+
+fn args_from_file(paths: Vec<String>) -> Result<Vec<String>, OptionError> {
+    let mut args = vec![];
+    for path in paths.into_iter() {
+        let mut lines = read_file_to_array(path).map_err(OptionError::Generic)?;
+        args.append(&mut lines);
+    }
+    Ok(args)
+}
+
+fn env_from_files(paths: Vec<String>) -> Result<HashMap<String, String>, OptionError> {
+    let mut env_vars = HashMap::new();
+    for path in paths.into_iter() {
+        let lines = read_file_to_array(path).map_err(OptionError::Generic)?;
+        for line in lines.into_iter() {
+            let (k, v) = line
+                .split_once('=')
+                .ok_or_else(|| OptionError::Generic("environment file invalid".to_owned()))?;
+            env_vars.insert(k.to_owned(), v.to_owned());
+        }
+    }
+    Ok(env_vars)
+}
+
+fn prepare_args(mut args: Vec<String>, subst_mappings: &[(String, String)]) -> Vec<String> {
+    for (f, replace_with) in subst_mappings {
+        for arg in args.iter_mut() {
+            let from = format!("${{{}}}", f);
+            let new = arg.replace(from.as_str(), replace_with);
+            *arg = new;
+        }
+    }
+    args
+}
+
+fn environment_block(
+    environment_file_block: HashMap<String, String>,
+    stamp_mappings: &[(String, String)],
+    subst_mappings: &[(String, String)],
+) -> HashMap<String, String> {
+    // Taking all environment variables from the current process
+    // and sending them down to the child process
+    let mut environment_variables: HashMap<String, String> = std::env::vars().collect();
+    // Have the last values added take precedence over the first.
+    // This is simpler than needing to track duplicates and explicitly override
+    // them.
+    environment_variables.extend(environment_file_block.into_iter());
+    for (f, replace_with) in stamp_mappings {
+        for value in environment_variables.values_mut() {
+            let from = format!("{{{}}}", f);
+            let new = value.replace(from.as_str(), replace_with);
+            *value = new;
+        }
+    }
+    for (f, replace_with) in subst_mappings {
+        for value in environment_variables.values_mut() {
+            let from = format!("${{{}}}", f);
+            let new = value.replace(from.as_str(), replace_with);
+            *value = new;
+        }
+    }
+    environment_variables
+}
diff --git a/third_party/rules_rust/util/process_wrapper/util.rs b/third_party/rules_rust/util/process_wrapper/util.rs
new file mode 100644
index 0000000..4b3d6bb
--- /dev/null
+++ b/third_party/rules_rust/util/process_wrapper/util.rs
@@ -0,0 +1,103 @@
+// Copyright 2020 The Bazel Authors. All rights reserved.
+//
+// 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.
+
+use std::fs::File;
+use std::io::{BufRead, BufReader, Read};
+
+pub(crate) fn read_file_to_array(path: String) -> Result<Vec<String>, String> {
+    let file = File::open(path).map_err(|e| e.to_string())?;
+    read_to_array(file)
+}
+
+pub(crate) fn read_stamp_status_to_array(path: String) -> Result<Vec<(String, String)>, String> {
+    let file = File::open(path).map_err(|e| e.to_string())?;
+    stamp_status_to_array(file)
+}
+
+fn read_to_array(reader: impl Read) -> Result<Vec<String>, String> {
+    let reader = BufReader::new(reader);
+    let mut ret = vec![];
+    let mut escaped_line = String::new();
+    for l in reader.lines() {
+        let line = l.map_err(|e| e.to_string())?;
+        if line.is_empty() {
+            continue;
+        }
+        // a \ at the end of a line allows us to escape the new line break,
+        // \\ yields a single \, so \\\ translates to a single \ and a new line
+        // escape
+        let end_backslash_count = line.chars().rev().take_while(|&c| c == '\\').count();
+        // a 0 or even number of backslashes do not lead to a new line escape
+        let escape = end_backslash_count % 2 == 1;
+        //  remove backslashes and add back two for every one
+        let l = line.trim_end_matches('\\');
+        escaped_line.push_str(l);
+        for _ in 0..end_backslash_count / 2 {
+            escaped_line.push('\\');
+        }
+        if escape {
+            // we add a newline as we expect a line after this
+            escaped_line.push('\n');
+        } else {
+            ret.push(escaped_line);
+            escaped_line = String::new();
+        }
+    }
+    Ok(ret)
+}
+
+fn stamp_status_to_array(reader: impl Read) -> Result<Vec<(String, String)>, String> {
+    let escaped_lines = read_to_array(reader)?;
+    escaped_lines
+        .into_iter()
+        .map(|l| {
+            let (s1, s2) = l
+                .split_once(' ')
+                .ok_or_else(|| format!("wrong workspace status file format for \"{}\"", l))?;
+            Ok((s1.to_owned(), s2.to_owned()))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_read_to_array() {
+        let input = r#"some escaped \\\
+string
+with other lines"#
+            .to_owned();
+        let expected = vec![
+            r#"some escaped \
+string"#,
+            "with other lines",
+        ];
+        let got = read_to_array(input.as_bytes()).unwrap();
+        assert_eq!(expected, got);
+    }
+
+    #[test]
+    fn test_stamp_status_to_array() {
+        let lines = "aaa bbb\\\nvvv\nccc ddd\neee fff";
+        let got = stamp_status_to_array(lines.as_bytes()).unwrap();
+        let expected = vec![
+            ("aaa".to_owned(), "bbb\nvvv".to_owned()),
+            ("ccc".to_owned(), "ddd".to_owned()),
+            ("eee".to_owned(), "fff".to_owned()),
+        ];
+        assert_eq!(expected, got);
+    }
+}
diff --git a/third_party/rules_rust/wasm_bindgen/BUILD.bazel b/third_party/rules_rust/wasm_bindgen/BUILD.bazel
new file mode 100644
index 0000000..b69c85a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/BUILD.bazel
@@ -0,0 +1,29 @@
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//wasm_bindgen:wasm_bindgen.bzl", "rust_wasm_bindgen_toolchain")
+
+package(default_visibility = ["//visibility:public"])
+
+toolchain_type(name = "wasm_bindgen_toolchain")
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = glob(["**/*.bzl"]) + ["//wasm_bindgen/raze:crates.bzl"],
+    deps = ["//rust:bzl_lib"],
+)
+
+alias(
+    name = "rules",
+    actual = ":bzl_lib",
+    deprecation = "Please use the `@rules_rust//wasm_bindgen:bzl_lib` target instead",
+)
+
+rust_wasm_bindgen_toolchain(
+    name = "default_wasm_bindgen_toolchain_impl",
+    bindgen = "//wasm_bindgen/raze:cargo_bin_wasm_bindgen",
+)
+
+toolchain(
+    name = "default_wasm_bindgen_toolchain",
+    toolchain = "default_wasm_bindgen_toolchain_impl",
+    toolchain_type = "//wasm_bindgen:wasm_bindgen_toolchain",
+)
diff --git a/third_party/rules_rust/wasm_bindgen/README.md b/third_party/rules_rust/wasm_bindgen/README.md
new file mode 100644
index 0000000..c4066f4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/README.md
@@ -0,0 +1,8 @@
+# Rust WebAssembly Bindgen Rules
+
+These rules are for using [Wasm Bindgen][wasm_bindgen] to generate [Rust][rust] bindings to.
+
+[rust]: http://www.rust-lang.org/
+[wasm_bindgen]: https://github.com/rustwasm/wasm-bindgen
+
+More information can be found in the [rules_rust documentation](https://bazelbuild.github.io/rules_rust/rust_wasm_bindgen.html).
diff --git a/third_party/rules_rust/wasm_bindgen/providers.bzl b/third_party/rules_rust/wasm_bindgen/providers.bzl
new file mode 100644
index 0000000..fc7123c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/providers.bzl
@@ -0,0 +1,14 @@
+"""A module for re-exporting the providers used by the rust_wasm_bindgen rule"""
+
+load(
+    "@build_bazel_rules_nodejs//:providers.bzl",
+    _DeclarationInfo = "DeclarationInfo",
+    _JSEcmaScriptModuleInfo = "JSEcmaScriptModuleInfo",
+    _JSModuleInfo = "JSModuleInfo",
+    _JSNamedModuleInfo = "JSNamedModuleInfo",
+)
+
+DeclarationInfo = _DeclarationInfo
+JSEcmaScriptModuleInfo = _JSEcmaScriptModuleInfo
+JSModuleInfo = _JSModuleInfo
+JSNamedModuleInfo = _JSNamedModuleInfo
diff --git a/third_party/rules_rust/wasm_bindgen/raze/BUILD.bazel b/third_party/rules_rust/wasm_bindgen/raze/BUILD.bazel
new file mode 100644
index 0000000..c0f8472
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/BUILD.bazel
@@ -0,0 +1,237 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+package(default_visibility = ["//visibility:public"])
+
+licenses([
+    "notice",  # See individual crates for specific licenses
+])
+
+# Aliased targets
+alias(
+    name = "anyhow",
+    actual = "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "assert_cmd",
+    actual = "@rules_rust_wasm_bindgen__assert_cmd__1_0_8//:assert_cmd",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "curl",
+    actual = "@rules_rust_wasm_bindgen__curl__0_4_40//:curl",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "diff",
+    actual = "@rules_rust_wasm_bindgen__diff__0_1_12//:diff",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "docopt",
+    actual = "@rules_rust_wasm_bindgen__docopt__1_1_1//:docopt",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "env_logger",
+    actual = "@rules_rust_wasm_bindgen__env_logger__0_8_4//:env_logger",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "log",
+    actual = "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "predicates",
+    actual = "@rules_rust_wasm_bindgen__predicates__1_0_8//:predicates",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "rayon",
+    actual = "@rules_rust_wasm_bindgen__rayon__1_5_1//:rayon",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "rouille",
+    actual = "@rules_rust_wasm_bindgen__rouille__3_4_0//:rouille",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "serde",
+    actual = "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "serde_derive",
+    actual = "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "serde_json",
+    actual = "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "tempfile",
+    actual = "@rules_rust_wasm_bindgen__tempfile__3_2_0//:tempfile",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "walrus",
+    actual = "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wasm_bindgen",
+    actual = "@rules_rust_wasm_bindgen__wasm_bindgen__0_2_78//:wasm_bindgen",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "cargo_bin_wasm_bindgen",
+    actual = "@rules_rust_wasm_bindgen__wasm_bindgen_cli__0_2_78//:cargo_bin_wasm_bindgen",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wasm_bindgen_cli",
+    actual = "@rules_rust_wasm_bindgen__wasm_bindgen_cli__0_2_78//:wasm_bindgen_cli",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wasm_bindgen_cli_support",
+    actual = "@rules_rust_wasm_bindgen__wasm_bindgen_cli_support__0_2_78//:wasm_bindgen_cli_support",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wasm_bindgen_shared",
+    actual = "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wit_printer",
+    actual = "@rules_rust_wasm_bindgen__wit_printer__0_2_0//:wit_printer",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wit_text",
+    actual = "@rules_rust_wasm_bindgen__wit_text__0_8_0//:wit_text",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wit_validator",
+    actual = "@rules_rust_wasm_bindgen__wit_validator__0_2_1//:wit_validator",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+alias(
+    name = "wit_walrus",
+    actual = "@rules_rust_wasm_bindgen__wit_walrus__0_6_0//:wit_walrus",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+# Export file for Stardoc support
+exports_files(
+    [
+        "crates.bzl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/Cargo.raze.lock b/third_party/rules_rust/wasm_bindgen/raze/Cargo.raze.lock
new file mode 100644
index 0000000..59cccf2
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/Cargo.raze.lock
@@ -0,0 +1,1372 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7"
+
+[[package]]
+name = "ascii"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbf56136a5198c7b01a49e3afcbef6cf84597273d298f54432926024107b0109"
+
+[[package]]
+name = "assert_cmd"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe"
+dependencies = [
+ "bstr",
+ "doc-comment",
+ "predicates 2.0.3",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "base64"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
+dependencies = [
+ "byteorder",
+ "safemem",
+]
+
+[[package]]
+name = "base64"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bstr"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+dependencies = [
+ "lazy_static",
+ "memchr",
+ "regex-automata",
+]
+
+[[package]]
+name = "buf_redux"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f"
+dependencies = [
+ "memchr",
+ "safemem",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "cc"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+dependencies = [
+ "libc",
+ "num-integer",
+ "num-traits",
+ "winapi",
+]
+
+[[package]]
+name = "chunked_transfer"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "lazy_static",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+dependencies = [
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "curl"
+version = "0.4.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877cc2f9b8367e32b6dabb9d581557e651cb3aa693a37f8679091bbf42687d5d"
+dependencies = [
+ "curl-sys",
+ "libc",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "socket2",
+ "winapi",
+]
+
+[[package]]
+name = "curl-sys"
+version = "0.4.50+curl-7.79.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4856b76919dd599f31236bb18db5f5bd36e2ce131e64f857ca5c259665b76171"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+ "winapi",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+
+[[package]]
+name = "difference"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "docopt"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f3f119846c823f9eafcf953a8f6ffb6ed69bf6240883261a7f13b634579a51f"
+dependencies = [
+ "lazy_static",
+ "regex",
+ "serde",
+ "strsim",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "env_logger"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "fake_rules_rust_wasm_bindgen_lib"
+version = "0.0.1"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "975ccf83d8d9d0d84682850a38c8169027be83368805971cc4f238c2b245bc98"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "winapi",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+dependencies = [
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "httparse"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acd94fdbe1d4ff688b67b04eee2e17bd50995534a61539e45adfefb45e5e5503"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "id-arena"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+dependencies = [
+ "rayon",
+]
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
+name = "libc"
+version = "0.2.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+
+[[package]]
+name = "libz-sys"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "memoffset"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "multipart"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00dec633863867f29cb39df64a397cdf4a6354708ddd7759f70c7fb51c5f9182"
+dependencies = [
+ "buf_redux",
+ "httparse",
+ "log",
+ "mime",
+ "mime_guess",
+ "quick-error",
+ "rand",
+ "safemem",
+ "tempfile",
+ "twoway",
+]
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "num-integer"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
+
+[[package]]
+name = "openssl"
+version = "0.10.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+
+[[package]]
+name = "openssl-src"
+version = "300.0.2+3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14a760a11390b1a5daf72074d4f6ff1a6e772534ae191f999f57e9ee8146d1fb"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6517987b3f8226b5da3661dad65ff7f300cc59fb5ea8333ca191fc65fde3edf"
+dependencies = [
+ "autocfg",
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba"
+
+[[package]]
+name = "predicates"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f49cfaf7fdaa3bfacc6fa3e7054e65148878354a5cfddcf661df4c851f8021df"
+dependencies = [
+ "difference",
+ "float-cmp",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c6ce811d0b2e103743eec01db1c50612221f173084ce2f7941053e94b6bb474"
+dependencies = [
+ "difflib",
+ "itertools",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "338c7be2905b732ae3984a2f40032b5e94fd8f52505b186c7d4d68d193445df7"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+dependencies = [
+ "autocfg",
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "lazy_static",
+ "num_cpus",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "rouille"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "660f081d053ac1dce7c2683a3f2818d9b60a293bc142e7d3de36fd5541ebb671"
+dependencies = [
+ "base64 0.13.0",
+ "chrono",
+ "filetime",
+ "multipart",
+ "num_cpus",
+ "percent-encoding",
+ "rand",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha1",
+ "threadpool",
+ "time",
+ "tiny_http",
+ "url",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+
+[[package]]
+name = "ryu"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+
+[[package]]
+name = "safemem"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
+
+[[package]]
+name = "schannel"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+dependencies = [
+ "lazy_static",
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "serde"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e466864e431129c7e0d3476b92f20458e5879919a0596c6472738d9fa2d342f8"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2579985fda508104f7587689507983eadd6a6e84dd35d6d115361f530916fa0d"
+
+[[package]]
+name = "socket2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "termtree"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13a4ec180a2de59b57434704ccfad967f789b12737738798fa08798cd5824c16"
+
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
+[[package]]
+name = "time"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0a10c9a9fb3a5dce8c2239ed670f1a2569fcf42da035f5face1b19860d52b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "tiny_http"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce51b50006056f590c9b7c3808c3bd70f0d1101666629713866c227d6e58d39"
+dependencies = [
+ "ascii",
+ "chrono",
+ "chunked_transfer",
+ "log",
+ "url",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "twoway"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "unicase"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "url"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "matches",
+ "percent-encoding",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walrus"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4eb08e48cde54c05f363d984bb54ce374f49e242def9468d2e1b6c2372d291f8"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "leb128",
+ "log",
+ "rayon",
+ "walrus-macro",
+ "wasmparser 0.77.0",
+]
+
+[[package]]
+name = "walrus-macro"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e5bd22c71e77d60140b0bd5be56155a37e5bd14e24f5f87298040d0cc40d7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-cli"
+version = "0.2.78"
+dependencies = [
+ "anyhow",
+ "assert_cmd",
+ "curl",
+ "diff",
+ "docopt",
+ "env_logger",
+ "log",
+ "openssl",
+ "predicates 1.0.8",
+ "rayon",
+ "rouille",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tempfile",
+ "walrus",
+ "wasm-bindgen-cli-support",
+ "wasm-bindgen-shared",
+ "wit-printer",
+ "wit-text",
+ "wit-validator",
+ "wit-walrus",
+]
+
+[[package]]
+name = "wasm-bindgen-cli-support"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "676406c3960cf7d5a581f13e6015d9aff1521042510fd5139cf47baad2eb8a28"
+dependencies = [
+ "anyhow",
+ "base64 0.9.3",
+ "log",
+ "rustc-demangle",
+ "serde_json",
+ "tempfile",
+ "walrus",
+ "wasm-bindgen-externref-xform",
+ "wasm-bindgen-multi-value-xform",
+ "wasm-bindgen-shared",
+ "wasm-bindgen-threads-xform",
+ "wasm-bindgen-wasm-conventions",
+ "wasm-bindgen-wasm-interpreter",
+ "wit-text",
+ "wit-validator",
+ "wit-walrus",
+]
+
+[[package]]
+name = "wasm-bindgen-externref-xform"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47be83b4ede14262d9ff7a748ef956f9d78cca20097dcdd12b0214e7960d5f98"
+dependencies = [
+ "anyhow",
+ "walrus",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-multi-value-xform"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fe4a0115972f946060752b2a2cbf7d40a54715e4478b4b157dba1070b7f1b4"
+dependencies = [
+ "anyhow",
+ "walrus",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc"
+
+[[package]]
+name = "wasm-bindgen-threads-xform"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6e689ab91f6489df7790a853869cfbfe4c765a75714007be0f54277f8f0cca"
+dependencies = [
+ "anyhow",
+ "walrus",
+ "wasm-bindgen-wasm-conventions",
+]
+
+[[package]]
+name = "wasm-bindgen-wasm-conventions"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "811ac791b372687313fb22316a924e5828d1bfb3a100784e1f4eef348042a173"
+dependencies = [
+ "anyhow",
+ "walrus",
+]
+
+[[package]]
+name = "wasm-bindgen-wasm-interpreter"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "676462889d49300b5958686a633c0e1991fd1633cf45d41b05ca3c530c411b7f"
+dependencies = [
+ "anyhow",
+ "log",
+ "walrus",
+ "wasm-bindgen-wasm-conventions",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a950e6a618f62147fd514ff445b2a0b53120d382751960797f85f058c7eda9b9"
+
+[[package]]
+name = "wasmparser"
+version = "0.77.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b35c86d22e720a07d954ebbed772d01180501afe7d03d464f413bb5f8914a8d6"
+
+[[package]]
+name = "wasmparser"
+version = "0.81.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98930446519f63d00a836efdc22f67766ceae8dbcc1571379f2bcabc6b2b9abc"
+
+[[package]]
+name = "wasmprinter"
+version = "0.2.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00ad4a51ba74183137c776ab37dea50b9f71db7454d7b654c2ba69ac5d9b223"
+dependencies = [
+ "anyhow",
+ "wasmparser 0.81.0",
+]
+
+[[package]]
+name = "wast"
+version = "21.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b1844f66a2bc8526d71690104c0e78a8e59ffa1597b7245769d174ebb91deb5"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "wit-parser"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f5fd97866f4b9c8e1ed57bcf9446f3d0d8ba37e2dd01c3c612c046c053b06f7"
+dependencies = [
+ "anyhow",
+ "leb128",
+ "wit-schema-version",
+]
+
+[[package]]
+name = "wit-printer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93f19ca44555a3c14d69acee6447a6e4f52771b0c6e5d8db3e42db3b90f6fce9"
+dependencies = [
+ "anyhow",
+ "wasmprinter",
+ "wit-parser",
+ "wit-schema-version",
+]
+
+[[package]]
+name = "wit-schema-version"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfee4a6a4716eefa0682e7a3b836152e894a3e4f34a9d6c2c3e1c94429bfe36a"
+
+[[package]]
+name = "wit-text"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33358e95c77d660f1c7c07f4a93c2bd89768965e844e3c50730bb4b42658df5f"
+dependencies = [
+ "anyhow",
+ "wast",
+ "wit-writer",
+]
+
+[[package]]
+name = "wit-validator"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c11d93d925420e7872b226c4161849c32be38385ccab026b88df99d8ddc6ba6"
+dependencies = [
+ "anyhow",
+ "wasmparser 0.59.0",
+ "wit-parser",
+ "wit-schema-version",
+]
+
+[[package]]
+name = "wit-walrus"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad559e3e4c6404b2a6a675d44129d62a3836e3b951b90112fa1c5feb852757cd"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "walrus",
+ "wit-parser",
+ "wit-schema-version",
+ "wit-writer",
+]
+
+[[package]]
+name = "wit-writer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2ad01ba5e9cbcff799a0689e56a153776ea694cec777f605938cb9880d41a09"
+dependencies = [
+ "leb128",
+ "wit-schema-version",
+]
diff --git a/third_party/rules_rust/wasm_bindgen/raze/Cargo.toml b/third_party/rules_rust/wasm_bindgen/raze/Cargo.toml
new file mode 100644
index 0000000..cd901c4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "fake_rules_rust_wasm_bindgen_lib"
+version = "0.0.1"
+
+[lib]
+path = "fake_rules_rust_wasm_bindgen_lib.rs"
+
+[dependencies]
+wasm-bindgen = "0.2.78"
+
+[package.metadata.raze]
+genmode = "Remote"
+workspace_path = "//wasm_bindgen/raze"
+gen_workspace_prefix = "rules_rust_wasm_bindgen"
+rust_rules_workspace_name = "rules_rust"
+package_aliases_dir = "."
+default_gen_buildrs = true
+
+[package.metadata.raze.binary_deps]
+wasm-bindgen-cli = "0.2.78"
+
+[package.metadata.raze.crates.curl-sys.'*']
+gen_buildrs = false
+
+[package.metadata.raze.crates.log.'<5']
+additional_flags = [
+    "--cfg=atomic_cas",
+    "--cfg=use_std",
+]
+
+[package.metadata.raze.crates.openssl-sys.'*']
+gen_buildrs = false
+additional_flags = [
+  # Vendored openssl is 1.0.2m
+  "--cfg=ossl101",
+  "--cfg=ossl102",
+  "--cfg=ossl102f",
+  "--cfg=ossl102h",
+  "--cfg=ossl110",
+  "--cfg=ossl110f",
+  "--cfg=ossl110g",
+  "--cfg=ossl111",
+  "--cfg=ossl111b",
+  "-l",
+  "dylib=ssl",
+  "-l",
+  "dylib=crypto",
+]
+
+[package.metadata.raze.crates.proc-macro2.'*']
+additional_flags = [
+    "--cfg=use_proc_macro",
+]
+
+[package.metadata.raze.crates.unicase.'*']
+additional_flags = [
+  "--cfg=__unicase__iter_cmp",
+  "--cfg=__unicase__defauler_hasher",
+]
+
+[package.metadata.raze.crates.wasm-bindgen-cli.'*']
+extra_aliased_targets = ["cargo_bin_wasm_bindgen"]
diff --git a/third_party/rules_rust/wasm_bindgen/raze/crates.bzl b/third_party/rules_rust/wasm_bindgen/raze/crates.bzl
new file mode 100644
index 0000000..7addcce
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/crates.bzl
@@ -0,0 +1,1432 @@
+"""
+@generated
+cargo-raze generated Bazel file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")  # buildifier: disable=load
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")  # buildifier: disable=load
+
+def rules_rust_wasm_bindgen_fetch_remote_crates():
+    """This function defines a collection of repos and should be called in a WORKSPACE file"""
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__aho_corasick__0_7_18",
+        url = "https://crates.io/api/v1/crates/aho-corasick/0.7.18/download",
+        type = "tar.gz",
+        sha256 = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f",
+        strip_prefix = "aho-corasick-0.7.18",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.aho-corasick-0.7.18.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__anyhow__1_0_45",
+        url = "https://crates.io/api/v1/crates/anyhow/1.0.45/download",
+        type = "tar.gz",
+        sha256 = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7",
+        strip_prefix = "anyhow-1.0.45",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.anyhow-1.0.45.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__ascii__1_0_0",
+        url = "https://crates.io/api/v1/crates/ascii/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "bbf56136a5198c7b01a49e3afcbef6cf84597273d298f54432926024107b0109",
+        strip_prefix = "ascii-1.0.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.ascii-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__assert_cmd__1_0_8",
+        url = "https://crates.io/api/v1/crates/assert_cmd/1.0.8/download",
+        type = "tar.gz",
+        sha256 = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe",
+        strip_prefix = "assert_cmd-1.0.8",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.assert_cmd-1.0.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__atty__0_2_14",
+        url = "https://crates.io/api/v1/crates/atty/0.2.14/download",
+        type = "tar.gz",
+        sha256 = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8",
+        strip_prefix = "atty-0.2.14",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.atty-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__autocfg__1_0_1",
+        url = "https://crates.io/api/v1/crates/autocfg/1.0.1/download",
+        type = "tar.gz",
+        sha256 = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a",
+        strip_prefix = "autocfg-1.0.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.autocfg-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__base64__0_13_0",
+        url = "https://crates.io/api/v1/crates/base64/0.13.0/download",
+        type = "tar.gz",
+        sha256 = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd",
+        strip_prefix = "base64-0.13.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.base64-0.13.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__base64__0_9_3",
+        url = "https://crates.io/api/v1/crates/base64/0.9.3/download",
+        type = "tar.gz",
+        sha256 = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643",
+        strip_prefix = "base64-0.9.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.base64-0.9.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__bitflags__1_3_2",
+        url = "https://crates.io/api/v1/crates/bitflags/1.3.2/download",
+        type = "tar.gz",
+        sha256 = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",
+        strip_prefix = "bitflags-1.3.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.bitflags-1.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__bstr__0_2_17",
+        url = "https://crates.io/api/v1/crates/bstr/0.2.17/download",
+        type = "tar.gz",
+        sha256 = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223",
+        strip_prefix = "bstr-0.2.17",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.bstr-0.2.17.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__buf_redux__0_8_4",
+        url = "https://crates.io/api/v1/crates/buf_redux/0.8.4/download",
+        type = "tar.gz",
+        sha256 = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f",
+        strip_prefix = "buf_redux-0.8.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.buf_redux-0.8.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__bumpalo__3_8_0",
+        url = "https://crates.io/api/v1/crates/bumpalo/3.8.0/download",
+        type = "tar.gz",
+        sha256 = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c",
+        strip_prefix = "bumpalo-3.8.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.bumpalo-3.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__byteorder__1_4_3",
+        url = "https://crates.io/api/v1/crates/byteorder/1.4.3/download",
+        type = "tar.gz",
+        sha256 = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610",
+        strip_prefix = "byteorder-1.4.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.byteorder-1.4.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__cc__1_0_71",
+        url = "https://crates.io/api/v1/crates/cc/1.0.71/download",
+        type = "tar.gz",
+        sha256 = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd",
+        strip_prefix = "cc-1.0.71",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.cc-1.0.71.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__cfg_if__1_0_0",
+        url = "https://crates.io/api/v1/crates/cfg-if/1.0.0/download",
+        type = "tar.gz",
+        sha256 = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd",
+        strip_prefix = "cfg-if-1.0.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.cfg-if-1.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__chrono__0_4_19",
+        url = "https://crates.io/api/v1/crates/chrono/0.4.19/download",
+        type = "tar.gz",
+        sha256 = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73",
+        strip_prefix = "chrono-0.4.19",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.chrono-0.4.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__chunked_transfer__1_4_0",
+        url = "https://crates.io/api/v1/crates/chunked_transfer/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e",
+        strip_prefix = "chunked_transfer-1.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.chunked_transfer-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__crossbeam_channel__0_5_1",
+        url = "https://crates.io/api/v1/crates/crossbeam-channel/0.5.1/download",
+        type = "tar.gz",
+        sha256 = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4",
+        strip_prefix = "crossbeam-channel-0.5.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.crossbeam-channel-0.5.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__crossbeam_deque__0_8_1",
+        url = "https://crates.io/api/v1/crates/crossbeam-deque/0.8.1/download",
+        type = "tar.gz",
+        sha256 = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e",
+        strip_prefix = "crossbeam-deque-0.8.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.crossbeam-deque-0.8.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__crossbeam_epoch__0_9_5",
+        url = "https://crates.io/api/v1/crates/crossbeam-epoch/0.9.5/download",
+        type = "tar.gz",
+        sha256 = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd",
+        strip_prefix = "crossbeam-epoch-0.9.5",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.crossbeam-epoch-0.9.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__crossbeam_utils__0_8_5",
+        url = "https://crates.io/api/v1/crates/crossbeam-utils/0.8.5/download",
+        type = "tar.gz",
+        sha256 = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db",
+        strip_prefix = "crossbeam-utils-0.8.5",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.crossbeam-utils-0.8.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__curl__0_4_40",
+        url = "https://crates.io/api/v1/crates/curl/0.4.40/download",
+        type = "tar.gz",
+        sha256 = "877cc2f9b8367e32b6dabb9d581557e651cb3aa693a37f8679091bbf42687d5d",
+        strip_prefix = "curl-0.4.40",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.curl-0.4.40.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__curl_sys__0_4_50_curl_7_79_1",
+        url = "https://crates.io/api/v1/crates/curl-sys/0.4.50+curl-7.79.1/download",
+        type = "tar.gz",
+        sha256 = "4856b76919dd599f31236bb18db5f5bd36e2ce131e64f857ca5c259665b76171",
+        strip_prefix = "curl-sys-0.4.50+curl-7.79.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.curl-sys-0.4.50+curl-7.79.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__diff__0_1_12",
+        url = "https://crates.io/api/v1/crates/diff/0.1.12/download",
+        type = "tar.gz",
+        sha256 = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499",
+        strip_prefix = "diff-0.1.12",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.diff-0.1.12.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__difference__2_0_0",
+        url = "https://crates.io/api/v1/crates/difference/2.0.0/download",
+        type = "tar.gz",
+        sha256 = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198",
+        strip_prefix = "difference-2.0.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.difference-2.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__difflib__0_4_0",
+        url = "https://crates.io/api/v1/crates/difflib/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8",
+        strip_prefix = "difflib-0.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.difflib-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__doc_comment__0_3_3",
+        url = "https://crates.io/api/v1/crates/doc-comment/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10",
+        strip_prefix = "doc-comment-0.3.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.doc-comment-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__docopt__1_1_1",
+        url = "https://crates.io/api/v1/crates/docopt/1.1.1/download",
+        type = "tar.gz",
+        sha256 = "7f3f119846c823f9eafcf953a8f6ffb6ed69bf6240883261a7f13b634579a51f",
+        strip_prefix = "docopt-1.1.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.docopt-1.1.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__either__1_6_1",
+        url = "https://crates.io/api/v1/crates/either/1.6.1/download",
+        type = "tar.gz",
+        sha256 = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457",
+        strip_prefix = "either-1.6.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.either-1.6.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__env_logger__0_8_4",
+        url = "https://crates.io/api/v1/crates/env_logger/0.8.4/download",
+        type = "tar.gz",
+        sha256 = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3",
+        strip_prefix = "env_logger-0.8.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.env_logger-0.8.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__filetime__0_2_15",
+        url = "https://crates.io/api/v1/crates/filetime/0.2.15/download",
+        type = "tar.gz",
+        sha256 = "975ccf83d8d9d0d84682850a38c8169027be83368805971cc4f238c2b245bc98",
+        strip_prefix = "filetime-0.2.15",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.filetime-0.2.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__float_cmp__0_8_0",
+        url = "https://crates.io/api/v1/crates/float-cmp/0.8.0/download",
+        type = "tar.gz",
+        sha256 = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4",
+        strip_prefix = "float-cmp-0.8.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.float-cmp-0.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__form_urlencoded__1_0_1",
+        url = "https://crates.io/api/v1/crates/form_urlencoded/1.0.1/download",
+        type = "tar.gz",
+        sha256 = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191",
+        strip_prefix = "form_urlencoded-1.0.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.form_urlencoded-1.0.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__getrandom__0_2_3",
+        url = "https://crates.io/api/v1/crates/getrandom/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753",
+        strip_prefix = "getrandom-0.2.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.getrandom-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__heck__0_3_3",
+        url = "https://crates.io/api/v1/crates/heck/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c",
+        strip_prefix = "heck-0.3.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.heck-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__hermit_abi__0_1_19",
+        url = "https://crates.io/api/v1/crates/hermit-abi/0.1.19/download",
+        type = "tar.gz",
+        sha256 = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33",
+        strip_prefix = "hermit-abi-0.1.19",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.hermit-abi-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__httparse__1_5_1",
+        url = "https://crates.io/api/v1/crates/httparse/1.5.1/download",
+        type = "tar.gz",
+        sha256 = "acd94fdbe1d4ff688b67b04eee2e17bd50995534a61539e45adfefb45e5e5503",
+        strip_prefix = "httparse-1.5.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.httparse-1.5.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__humantime__2_1_0",
+        url = "https://crates.io/api/v1/crates/humantime/2.1.0/download",
+        type = "tar.gz",
+        sha256 = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4",
+        strip_prefix = "humantime-2.1.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.humantime-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__id_arena__2_2_1",
+        url = "https://crates.io/api/v1/crates/id-arena/2.2.1/download",
+        type = "tar.gz",
+        sha256 = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005",
+        strip_prefix = "id-arena-2.2.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.id-arena-2.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__idna__0_2_3",
+        url = "https://crates.io/api/v1/crates/idna/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8",
+        strip_prefix = "idna-0.2.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.idna-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__itertools__0_10_1",
+        url = "https://crates.io/api/v1/crates/itertools/0.10.1/download",
+        type = "tar.gz",
+        sha256 = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf",
+        strip_prefix = "itertools-0.10.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.itertools-0.10.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__itoa__0_4_8",
+        url = "https://crates.io/api/v1/crates/itoa/0.4.8/download",
+        type = "tar.gz",
+        sha256 = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4",
+        strip_prefix = "itoa-0.4.8",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.itoa-0.4.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__lazy_static__1_4_0",
+        url = "https://crates.io/api/v1/crates/lazy_static/1.4.0/download",
+        type = "tar.gz",
+        sha256 = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646",
+        strip_prefix = "lazy_static-1.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.lazy_static-1.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__leb128__0_2_5",
+        url = "https://crates.io/api/v1/crates/leb128/0.2.5/download",
+        type = "tar.gz",
+        sha256 = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67",
+        strip_prefix = "leb128-0.2.5",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.leb128-0.2.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__libc__0_2_107",
+        url = "https://crates.io/api/v1/crates/libc/0.2.107/download",
+        type = "tar.gz",
+        sha256 = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219",
+        strip_prefix = "libc-0.2.107",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.libc-0.2.107.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__libz_sys__1_1_3",
+        url = "https://crates.io/api/v1/crates/libz-sys/1.1.3/download",
+        type = "tar.gz",
+        sha256 = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66",
+        strip_prefix = "libz-sys-1.1.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.libz-sys-1.1.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__log__0_4_14",
+        url = "https://crates.io/api/v1/crates/log/0.4.14/download",
+        type = "tar.gz",
+        sha256 = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710",
+        strip_prefix = "log-0.4.14",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.log-0.4.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__matches__0_1_9",
+        url = "https://crates.io/api/v1/crates/matches/0.1.9/download",
+        type = "tar.gz",
+        sha256 = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f",
+        strip_prefix = "matches-0.1.9",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.matches-0.1.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__memchr__2_4_1",
+        url = "https://crates.io/api/v1/crates/memchr/2.4.1/download",
+        type = "tar.gz",
+        sha256 = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a",
+        strip_prefix = "memchr-2.4.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.memchr-2.4.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__memoffset__0_6_4",
+        url = "https://crates.io/api/v1/crates/memoffset/0.6.4/download",
+        type = "tar.gz",
+        sha256 = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9",
+        strip_prefix = "memoffset-0.6.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.memoffset-0.6.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__mime__0_3_16",
+        url = "https://crates.io/api/v1/crates/mime/0.3.16/download",
+        type = "tar.gz",
+        sha256 = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d",
+        strip_prefix = "mime-0.3.16",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.mime-0.3.16.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__mime_guess__2_0_3",
+        url = "https://crates.io/api/v1/crates/mime_guess/2.0.3/download",
+        type = "tar.gz",
+        sha256 = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212",
+        strip_prefix = "mime_guess-2.0.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.mime_guess-2.0.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__multipart__0_18_0",
+        url = "https://crates.io/api/v1/crates/multipart/0.18.0/download",
+        type = "tar.gz",
+        sha256 = "00dec633863867f29cb39df64a397cdf4a6354708ddd7759f70c7fb51c5f9182",
+        strip_prefix = "multipart-0.18.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.multipart-0.18.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__normalize_line_endings__0_3_0",
+        url = "https://crates.io/api/v1/crates/normalize-line-endings/0.3.0/download",
+        type = "tar.gz",
+        sha256 = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be",
+        strip_prefix = "normalize-line-endings-0.3.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.normalize-line-endings-0.3.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__num_integer__0_1_44",
+        url = "https://crates.io/api/v1/crates/num-integer/0.1.44/download",
+        type = "tar.gz",
+        sha256 = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db",
+        strip_prefix = "num-integer-0.1.44",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.num-integer-0.1.44.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__num_traits__0_2_14",
+        url = "https://crates.io/api/v1/crates/num-traits/0.2.14/download",
+        type = "tar.gz",
+        sha256 = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290",
+        strip_prefix = "num-traits-0.2.14",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.num-traits-0.2.14.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__num_cpus__1_13_0",
+        url = "https://crates.io/api/v1/crates/num_cpus/1.13.0/download",
+        type = "tar.gz",
+        sha256 = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3",
+        strip_prefix = "num_cpus-1.13.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.num_cpus-1.13.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__openssl_probe__0_1_4",
+        url = "https://crates.io/api/v1/crates/openssl-probe/0.1.4/download",
+        type = "tar.gz",
+        sha256 = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a",
+        strip_prefix = "openssl-probe-0.1.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.openssl-probe-0.1.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__openssl_sys__0_9_70",
+        url = "https://crates.io/api/v1/crates/openssl-sys/0.9.70/download",
+        type = "tar.gz",
+        sha256 = "c6517987b3f8226b5da3661dad65ff7f300cc59fb5ea8333ca191fc65fde3edf",
+        strip_prefix = "openssl-sys-0.9.70",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.openssl-sys-0.9.70.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__percent_encoding__2_1_0",
+        url = "https://crates.io/api/v1/crates/percent-encoding/2.1.0/download",
+        type = "tar.gz",
+        sha256 = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e",
+        strip_prefix = "percent-encoding-2.1.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.percent-encoding-2.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__pkg_config__0_3_22",
+        url = "https://crates.io/api/v1/crates/pkg-config/0.3.22/download",
+        type = "tar.gz",
+        sha256 = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f",
+        strip_prefix = "pkg-config-0.3.22",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.pkg-config-0.3.22.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__ppv_lite86__0_2_15",
+        url = "https://crates.io/api/v1/crates/ppv-lite86/0.2.15/download",
+        type = "tar.gz",
+        sha256 = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba",
+        strip_prefix = "ppv-lite86-0.2.15",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.ppv-lite86-0.2.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__predicates__1_0_8",
+        url = "https://crates.io/api/v1/crates/predicates/1.0.8/download",
+        type = "tar.gz",
+        sha256 = "f49cfaf7fdaa3bfacc6fa3e7054e65148878354a5cfddcf661df4c851f8021df",
+        strip_prefix = "predicates-1.0.8",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.predicates-1.0.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__predicates__2_0_3",
+        url = "https://crates.io/api/v1/crates/predicates/2.0.3/download",
+        type = "tar.gz",
+        sha256 = "5c6ce811d0b2e103743eec01db1c50612221f173084ce2f7941053e94b6bb474",
+        strip_prefix = "predicates-2.0.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.predicates-2.0.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__predicates_core__1_0_2",
+        url = "https://crates.io/api/v1/crates/predicates-core/1.0.2/download",
+        type = "tar.gz",
+        sha256 = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451",
+        strip_prefix = "predicates-core-1.0.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.predicates-core-1.0.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__predicates_tree__1_0_4",
+        url = "https://crates.io/api/v1/crates/predicates-tree/1.0.4/download",
+        type = "tar.gz",
+        sha256 = "338c7be2905b732ae3984a2f40032b5e94fd8f52505b186c7d4d68d193445df7",
+        strip_prefix = "predicates-tree-1.0.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.predicates-tree-1.0.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__proc_macro2__1_0_32",
+        url = "https://crates.io/api/v1/crates/proc-macro2/1.0.32/download",
+        type = "tar.gz",
+        sha256 = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43",
+        strip_prefix = "proc-macro2-1.0.32",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.proc-macro2-1.0.32.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__quick_error__1_2_3",
+        url = "https://crates.io/api/v1/crates/quick-error/1.2.3/download",
+        type = "tar.gz",
+        sha256 = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0",
+        strip_prefix = "quick-error-1.2.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.quick-error-1.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__quote__1_0_10",
+        url = "https://crates.io/api/v1/crates/quote/1.0.10/download",
+        type = "tar.gz",
+        sha256 = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05",
+        strip_prefix = "quote-1.0.10",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.quote-1.0.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rand__0_8_4",
+        url = "https://crates.io/api/v1/crates/rand/0.8.4/download",
+        type = "tar.gz",
+        sha256 = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8",
+        strip_prefix = "rand-0.8.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rand-0.8.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rand_chacha__0_3_1",
+        url = "https://crates.io/api/v1/crates/rand_chacha/0.3.1/download",
+        type = "tar.gz",
+        sha256 = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88",
+        strip_prefix = "rand_chacha-0.3.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rand_chacha-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rand_core__0_6_3",
+        url = "https://crates.io/api/v1/crates/rand_core/0.6.3/download",
+        type = "tar.gz",
+        sha256 = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7",
+        strip_prefix = "rand_core-0.6.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rand_core-0.6.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rand_hc__0_3_1",
+        url = "https://crates.io/api/v1/crates/rand_hc/0.3.1/download",
+        type = "tar.gz",
+        sha256 = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7",
+        strip_prefix = "rand_hc-0.3.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rand_hc-0.3.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rayon__1_5_1",
+        url = "https://crates.io/api/v1/crates/rayon/1.5.1/download",
+        type = "tar.gz",
+        sha256 = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90",
+        strip_prefix = "rayon-1.5.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rayon-1.5.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rayon_core__1_9_1",
+        url = "https://crates.io/api/v1/crates/rayon-core/1.9.1/download",
+        type = "tar.gz",
+        sha256 = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e",
+        strip_prefix = "rayon-core-1.9.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rayon-core-1.9.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__redox_syscall__0_2_10",
+        url = "https://crates.io/api/v1/crates/redox_syscall/0.2.10/download",
+        type = "tar.gz",
+        sha256 = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff",
+        strip_prefix = "redox_syscall-0.2.10",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.redox_syscall-0.2.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__regex__1_5_4",
+        url = "https://crates.io/api/v1/crates/regex/1.5.4/download",
+        type = "tar.gz",
+        sha256 = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461",
+        strip_prefix = "regex-1.5.4",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.regex-1.5.4.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__regex_automata__0_1_10",
+        url = "https://crates.io/api/v1/crates/regex-automata/0.1.10/download",
+        type = "tar.gz",
+        sha256 = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132",
+        strip_prefix = "regex-automata-0.1.10",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.regex-automata-0.1.10.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__regex_syntax__0_6_25",
+        url = "https://crates.io/api/v1/crates/regex-syntax/0.6.25/download",
+        type = "tar.gz",
+        sha256 = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b",
+        strip_prefix = "regex-syntax-0.6.25",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.regex-syntax-0.6.25.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__remove_dir_all__0_5_3",
+        url = "https://crates.io/api/v1/crates/remove_dir_all/0.5.3/download",
+        type = "tar.gz",
+        sha256 = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7",
+        strip_prefix = "remove_dir_all-0.5.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.remove_dir_all-0.5.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rouille__3_4_0",
+        url = "https://crates.io/api/v1/crates/rouille/3.4.0/download",
+        type = "tar.gz",
+        sha256 = "660f081d053ac1dce7c2683a3f2818d9b60a293bc142e7d3de36fd5541ebb671",
+        strip_prefix = "rouille-3.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rouille-3.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__rustc_demangle__0_1_21",
+        url = "https://crates.io/api/v1/crates/rustc-demangle/0.1.21/download",
+        type = "tar.gz",
+        sha256 = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342",
+        strip_prefix = "rustc-demangle-0.1.21",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.rustc-demangle-0.1.21.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__ryu__1_0_5",
+        url = "https://crates.io/api/v1/crates/ryu/1.0.5/download",
+        type = "tar.gz",
+        sha256 = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e",
+        strip_prefix = "ryu-1.0.5",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.ryu-1.0.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__safemem__0_3_3",
+        url = "https://crates.io/api/v1/crates/safemem/0.3.3/download",
+        type = "tar.gz",
+        sha256 = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072",
+        strip_prefix = "safemem-0.3.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.safemem-0.3.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__schannel__0_1_19",
+        url = "https://crates.io/api/v1/crates/schannel/0.1.19/download",
+        type = "tar.gz",
+        sha256 = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75",
+        strip_prefix = "schannel-0.1.19",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.schannel-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__scopeguard__1_1_0",
+        url = "https://crates.io/api/v1/crates/scopeguard/1.1.0/download",
+        type = "tar.gz",
+        sha256 = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd",
+        strip_prefix = "scopeguard-1.1.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.scopeguard-1.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__serde__1_0_130",
+        url = "https://crates.io/api/v1/crates/serde/1.0.130/download",
+        type = "tar.gz",
+        sha256 = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913",
+        strip_prefix = "serde-1.0.130",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.serde-1.0.130.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__serde_derive__1_0_130",
+        url = "https://crates.io/api/v1/crates/serde_derive/1.0.130/download",
+        type = "tar.gz",
+        sha256 = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b",
+        strip_prefix = "serde_derive-1.0.130",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.serde_derive-1.0.130.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__serde_json__1_0_69",
+        url = "https://crates.io/api/v1/crates/serde_json/1.0.69/download",
+        type = "tar.gz",
+        sha256 = "e466864e431129c7e0d3476b92f20458e5879919a0596c6472738d9fa2d342f8",
+        strip_prefix = "serde_json-1.0.69",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.serde_json-1.0.69.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__sha1__0_6_0",
+        url = "https://crates.io/api/v1/crates/sha1/0.6.0/download",
+        type = "tar.gz",
+        sha256 = "2579985fda508104f7587689507983eadd6a6e84dd35d6d115361f530916fa0d",
+        strip_prefix = "sha1-0.6.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.sha1-0.6.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__socket2__0_4_2",
+        url = "https://crates.io/api/v1/crates/socket2/0.4.2/download",
+        type = "tar.gz",
+        sha256 = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516",
+        strip_prefix = "socket2-0.4.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.socket2-0.4.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__strsim__0_10_0",
+        url = "https://crates.io/api/v1/crates/strsim/0.10.0/download",
+        type = "tar.gz",
+        sha256 = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623",
+        strip_prefix = "strsim-0.10.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.strsim-0.10.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__syn__1_0_81",
+        url = "https://crates.io/api/v1/crates/syn/1.0.81/download",
+        type = "tar.gz",
+        sha256 = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966",
+        strip_prefix = "syn-1.0.81",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.syn-1.0.81.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__tempfile__3_2_0",
+        url = "https://crates.io/api/v1/crates/tempfile/3.2.0/download",
+        type = "tar.gz",
+        sha256 = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22",
+        strip_prefix = "tempfile-3.2.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.tempfile-3.2.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__termcolor__1_1_2",
+        url = "https://crates.io/api/v1/crates/termcolor/1.1.2/download",
+        type = "tar.gz",
+        sha256 = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4",
+        strip_prefix = "termcolor-1.1.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.termcolor-1.1.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__termtree__0_2_3",
+        url = "https://crates.io/api/v1/crates/termtree/0.2.3/download",
+        type = "tar.gz",
+        sha256 = "13a4ec180a2de59b57434704ccfad967f789b12737738798fa08798cd5824c16",
+        strip_prefix = "termtree-0.2.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.termtree-0.2.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__threadpool__1_8_1",
+        url = "https://crates.io/api/v1/crates/threadpool/1.8.1/download",
+        type = "tar.gz",
+        sha256 = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa",
+        strip_prefix = "threadpool-1.8.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.threadpool-1.8.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__time__0_3_2",
+        url = "https://crates.io/api/v1/crates/time/0.3.2/download",
+        type = "tar.gz",
+        sha256 = "3e0a10c9a9fb3a5dce8c2239ed670f1a2569fcf42da035f5face1b19860d52b0",
+        strip_prefix = "time-0.3.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.time-0.3.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__tiny_http__0_8_2",
+        url = "https://crates.io/api/v1/crates/tiny_http/0.8.2/download",
+        type = "tar.gz",
+        sha256 = "9ce51b50006056f590c9b7c3808c3bd70f0d1101666629713866c227d6e58d39",
+        strip_prefix = "tiny_http-0.8.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.tiny_http-0.8.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__tinyvec__1_5_0",
+        url = "https://crates.io/api/v1/crates/tinyvec/1.5.0/download",
+        type = "tar.gz",
+        sha256 = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7",
+        strip_prefix = "tinyvec-1.5.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.tinyvec-1.5.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__tinyvec_macros__0_1_0",
+        url = "https://crates.io/api/v1/crates/tinyvec_macros/0.1.0/download",
+        type = "tar.gz",
+        sha256 = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c",
+        strip_prefix = "tinyvec_macros-0.1.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.tinyvec_macros-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__twoway__0_1_8",
+        url = "https://crates.io/api/v1/crates/twoway/0.1.8/download",
+        type = "tar.gz",
+        sha256 = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1",
+        strip_prefix = "twoway-0.1.8",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.twoway-0.1.8.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__unicase__2_6_0",
+        url = "https://crates.io/api/v1/crates/unicase/2.6.0/download",
+        type = "tar.gz",
+        sha256 = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6",
+        strip_prefix = "unicase-2.6.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.unicase-2.6.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__unicode_bidi__0_3_7",
+        url = "https://crates.io/api/v1/crates/unicode-bidi/0.3.7/download",
+        type = "tar.gz",
+        sha256 = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f",
+        strip_prefix = "unicode-bidi-0.3.7",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.unicode-bidi-0.3.7.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__unicode_normalization__0_1_19",
+        url = "https://crates.io/api/v1/crates/unicode-normalization/0.1.19/download",
+        type = "tar.gz",
+        sha256 = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9",
+        strip_prefix = "unicode-normalization-0.1.19",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.unicode-normalization-0.1.19.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__unicode_segmentation__1_8_0",
+        url = "https://crates.io/api/v1/crates/unicode-segmentation/1.8.0/download",
+        type = "tar.gz",
+        sha256 = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b",
+        strip_prefix = "unicode-segmentation-1.8.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.unicode-segmentation-1.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__unicode_xid__0_2_2",
+        url = "https://crates.io/api/v1/crates/unicode-xid/0.2.2/download",
+        type = "tar.gz",
+        sha256 = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3",
+        strip_prefix = "unicode-xid-0.2.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.unicode-xid-0.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__url__2_2_2",
+        url = "https://crates.io/api/v1/crates/url/2.2.2/download",
+        type = "tar.gz",
+        sha256 = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c",
+        strip_prefix = "url-2.2.2",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.url-2.2.2.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__vcpkg__0_2_15",
+        url = "https://crates.io/api/v1/crates/vcpkg/0.2.15/download",
+        type = "tar.gz",
+        sha256 = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426",
+        strip_prefix = "vcpkg-0.2.15",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.vcpkg-0.2.15.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__version_check__0_9_3",
+        url = "https://crates.io/api/v1/crates/version_check/0.9.3/download",
+        type = "tar.gz",
+        sha256 = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe",
+        strip_prefix = "version_check-0.9.3",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.version_check-0.9.3.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wait_timeout__0_2_0",
+        url = "https://crates.io/api/v1/crates/wait-timeout/0.2.0/download",
+        type = "tar.gz",
+        sha256 = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6",
+        strip_prefix = "wait-timeout-0.2.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wait-timeout-0.2.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__walrus__0_19_0",
+        url = "https://crates.io/api/v1/crates/walrus/0.19.0/download",
+        type = "tar.gz",
+        sha256 = "4eb08e48cde54c05f363d984bb54ce374f49e242def9468d2e1b6c2372d291f8",
+        strip_prefix = "walrus-0.19.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.walrus-0.19.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__walrus_macro__0_19_0",
+        url = "https://crates.io/api/v1/crates/walrus-macro/0.19.0/download",
+        type = "tar.gz",
+        sha256 = "0a6e5bd22c71e77d60140b0bd5be56155a37e5bd14e24f5f87298040d0cc40d7",
+        strip_prefix = "walrus-macro-0.19.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.walrus-macro-0.19.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasi__0_10_2_wasi_snapshot_preview1",
+        url = "https://crates.io/api/v1/crates/wasi/0.10.2+wasi-snapshot-preview1/download",
+        type = "tar.gz",
+        sha256 = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6",
+        strip_prefix = "wasi-0.10.2+wasi-snapshot-preview1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce",
+        strip_prefix = "wasm-bindgen-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_backend__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-backend/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b",
+        strip_prefix = "wasm-bindgen-backend-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-backend-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_cli__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-cli/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "262a79690c18f5160ca109e839814783e29b71f1fd28448f80838145f93c08b6",
+        strip_prefix = "wasm-bindgen-cli-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-cli-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_cli_support__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-cli-support/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "676406c3960cf7d5a581f13e6015d9aff1521042510fd5139cf47baad2eb8a28",
+        strip_prefix = "wasm-bindgen-cli-support-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-cli-support-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_externref_xform__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-externref-xform/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "47be83b4ede14262d9ff7a748ef956f9d78cca20097dcdd12b0214e7960d5f98",
+        strip_prefix = "wasm-bindgen-externref-xform-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-externref-xform-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_macro__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-macro/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9",
+        strip_prefix = "wasm-bindgen-macro-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-macro-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_macro_support__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-macro-support/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab",
+        strip_prefix = "wasm-bindgen-macro-support-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-macro-support-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_multi_value_xform__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-multi-value-xform/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "97fe4a0115972f946060752b2a2cbf7d40a54715e4478b4b157dba1070b7f1b4",
+        strip_prefix = "wasm-bindgen-multi-value-xform-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-multi-value-xform-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-shared/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc",
+        strip_prefix = "wasm-bindgen-shared-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-shared-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_threads_xform__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-threads-xform/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "2d6e689ab91f6489df7790a853869cfbfe4c765a75714007be0f54277f8f0cca",
+        strip_prefix = "wasm-bindgen-threads-xform-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-threads-xform-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_wasm_conventions__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-wasm-conventions/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "811ac791b372687313fb22316a924e5828d1bfb3a100784e1f4eef348042a173",
+        strip_prefix = "wasm-bindgen-wasm-conventions-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-wasm-conventions-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasm_bindgen_wasm_interpreter__0_2_78",
+        url = "https://crates.io/api/v1/crates/wasm-bindgen-wasm-interpreter/0.2.78/download",
+        type = "tar.gz",
+        sha256 = "676462889d49300b5958686a633c0e1991fd1633cf45d41b05ca3c530c411b7f",
+        strip_prefix = "wasm-bindgen-wasm-interpreter-0.2.78",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasm-bindgen-wasm-interpreter-0.2.78.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasmparser__0_59_0",
+        url = "https://crates.io/api/v1/crates/wasmparser/0.59.0/download",
+        type = "tar.gz",
+        sha256 = "a950e6a618f62147fd514ff445b2a0b53120d382751960797f85f058c7eda9b9",
+        strip_prefix = "wasmparser-0.59.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasmparser-0.59.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasmparser__0_77_0",
+        url = "https://crates.io/api/v1/crates/wasmparser/0.77.0/download",
+        type = "tar.gz",
+        sha256 = "b35c86d22e720a07d954ebbed772d01180501afe7d03d464f413bb5f8914a8d6",
+        strip_prefix = "wasmparser-0.77.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasmparser-0.77.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasmparser__0_81_0",
+        url = "https://crates.io/api/v1/crates/wasmparser/0.81.0/download",
+        type = "tar.gz",
+        sha256 = "98930446519f63d00a836efdc22f67766ceae8dbcc1571379f2bcabc6b2b9abc",
+        strip_prefix = "wasmparser-0.81.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasmparser-0.81.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wasmprinter__0_2_31",
+        url = "https://crates.io/api/v1/crates/wasmprinter/0.2.31/download",
+        type = "tar.gz",
+        sha256 = "a00ad4a51ba74183137c776ab37dea50b9f71db7454d7b654c2ba69ac5d9b223",
+        strip_prefix = "wasmprinter-0.2.31",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wasmprinter-0.2.31.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wast__21_0_0",
+        url = "https://crates.io/api/v1/crates/wast/21.0.0/download",
+        type = "tar.gz",
+        sha256 = "0b1844f66a2bc8526d71690104c0e78a8e59ffa1597b7245769d174ebb91deb5",
+        strip_prefix = "wast-21.0.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wast-21.0.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__winapi__0_3_9",
+        url = "https://crates.io/api/v1/crates/winapi/0.3.9/download",
+        type = "tar.gz",
+        sha256 = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",
+        strip_prefix = "winapi-0.3.9",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.winapi-0.3.9.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__winapi_i686_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-i686-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",
+        strip_prefix = "winapi-i686-pc-windows-gnu-0.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__winapi_util__0_1_5",
+        url = "https://crates.io/api/v1/crates/winapi-util/0.1.5/download",
+        type = "tar.gz",
+        sha256 = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178",
+        strip_prefix = "winapi-util-0.1.5",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.winapi-util-0.1.5.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__winapi_x86_64_pc_windows_gnu__0_4_0",
+        url = "https://crates.io/api/v1/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download",
+        type = "tar.gz",
+        sha256 = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",
+        strip_prefix = "winapi-x86_64-pc-windows-gnu-0.4.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_parser__0_2_0",
+        url = "https://crates.io/api/v1/crates/wit-parser/0.2.0/download",
+        type = "tar.gz",
+        sha256 = "3f5fd97866f4b9c8e1ed57bcf9446f3d0d8ba37e2dd01c3c612c046c053b06f7",
+        strip_prefix = "wit-parser-0.2.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-parser-0.2.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_printer__0_2_0",
+        url = "https://crates.io/api/v1/crates/wit-printer/0.2.0/download",
+        type = "tar.gz",
+        sha256 = "93f19ca44555a3c14d69acee6447a6e4f52771b0c6e5d8db3e42db3b90f6fce9",
+        strip_prefix = "wit-printer-0.2.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-printer-0.2.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_schema_version__0_1_0",
+        url = "https://crates.io/api/v1/crates/wit-schema-version/0.1.0/download",
+        type = "tar.gz",
+        sha256 = "bfee4a6a4716eefa0682e7a3b836152e894a3e4f34a9d6c2c3e1c94429bfe36a",
+        strip_prefix = "wit-schema-version-0.1.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-schema-version-0.1.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_text__0_8_0",
+        url = "https://crates.io/api/v1/crates/wit-text/0.8.0/download",
+        type = "tar.gz",
+        sha256 = "33358e95c77d660f1c7c07f4a93c2bd89768965e844e3c50730bb4b42658df5f",
+        strip_prefix = "wit-text-0.8.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-text-0.8.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_validator__0_2_1",
+        url = "https://crates.io/api/v1/crates/wit-validator/0.2.1/download",
+        type = "tar.gz",
+        sha256 = "3c11d93d925420e7872b226c4161849c32be38385ccab026b88df99d8ddc6ba6",
+        strip_prefix = "wit-validator-0.2.1",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-validator-0.2.1.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_walrus__0_6_0",
+        url = "https://crates.io/api/v1/crates/wit-walrus/0.6.0/download",
+        type = "tar.gz",
+        sha256 = "ad559e3e4c6404b2a6a675d44129d62a3836e3b951b90112fa1c5feb852757cd",
+        strip_prefix = "wit-walrus-0.6.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-walrus-0.6.0.bazel"),
+    )
+
+    maybe(
+        http_archive,
+        name = "rules_rust_wasm_bindgen__wit_writer__0_2_0",
+        url = "https://crates.io/api/v1/crates/wit-writer/0.2.0/download",
+        type = "tar.gz",
+        sha256 = "c2ad01ba5e9cbcff799a0689e56a153776ea694cec777f605938cb9880d41a09",
+        strip_prefix = "wit-writer-0.2.0",
+        build_file = Label("//wasm_bindgen/raze/remote:BUILD.wit-writer-0.2.0.bazel"),
+    )
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel
new file mode 100644
index 0000000..9dea26c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.aho-corasick-0.7.18.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "aho_corasick",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.7.18",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__memchr__2_4_1//:memchr",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.anyhow-1.0.45.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.anyhow-1.0.45.bazel
new file mode 100644
index 0000000..d9dd44d
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.anyhow-1.0.45.bazel
@@ -0,0 +1,113 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "anyhow_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.45",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "anyhow",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.45",
+    # buildifier: leave-alone
+    deps = [
+        ":anyhow_build_script",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test_autotrait" with type "test" omitted
+
+# Unsupported target "test_backtrace" with type "test" omitted
+
+# Unsupported target "test_boxed" with type "test" omitted
+
+# Unsupported target "test_chain" with type "test" omitted
+
+# Unsupported target "test_context" with type "test" omitted
+
+# Unsupported target "test_convert" with type "test" omitted
+
+# Unsupported target "test_downcast" with type "test" omitted
+
+# Unsupported target "test_ffi" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
+
+# Unsupported target "test_macros" with type "test" omitted
+
+# Unsupported target "test_repr" with type "test" omitted
+
+# Unsupported target "test_source" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ascii-1.0.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ascii-1.0.0.bazel
new file mode 100644
index 0000000..3d4c9a7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ascii-1.0.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "ascii",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.assert_cmd-1.0.8.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.assert_cmd-1.0.8.bazel
new file mode 100644
index 0000000..b918152
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.assert_cmd-1.0.8.bazel
@@ -0,0 +1,97 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_bin_fixture",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/bin_fixture.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.8",
+    # buildifier: leave-alone
+    deps = [
+        ":assert_cmd",
+        "@rules_rust_wasm_bindgen__bstr__0_2_17//:bstr",
+        "@rules_rust_wasm_bindgen__doc_comment__0_3_3//:doc_comment",
+        "@rules_rust_wasm_bindgen__predicates__2_0_3//:predicates",
+        "@rules_rust_wasm_bindgen__predicates_core__1_0_2//:predicates_core",
+        "@rules_rust_wasm_bindgen__predicates_tree__1_0_4//:predicates_tree",
+        "@rules_rust_wasm_bindgen__wait_timeout__0_2_0//:wait_timeout",
+    ],
+)
+
+# Unsupported target "example_fixture" with type "example" omitted
+
+rust_library(
+    name = "assert_cmd",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.8",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__bstr__0_2_17//:bstr",
+        "@rules_rust_wasm_bindgen__doc_comment__0_3_3//:doc_comment",
+        "@rules_rust_wasm_bindgen__predicates__2_0_3//:predicates",
+        "@rules_rust_wasm_bindgen__predicates_core__1_0_2//:predicates_core",
+        "@rules_rust_wasm_bindgen__predicates_tree__1_0_4//:predicates_tree",
+        "@rules_rust_wasm_bindgen__wait_timeout__0_2_0//:wait_timeout",
+    ],
+)
+
+# Unsupported target "assert" with type "test" omitted
+
+# Unsupported target "cargo" with type "test" omitted
+
+# Unsupported target "examples" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.atty-0.2.14.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.atty-0.2.14.bazel
new file mode 100644
index 0000000..7764145
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.atty-0.2.14.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "atty" with type "example" omitted
+
+rust_library(
+    name = "atty",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.14",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.autocfg-1.0.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.autocfg-1.0.1.bazel
new file mode 100644
index 0000000..867f1ef
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.autocfg-1.0.1.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "integers" with type "example" omitted
+
+# Unsupported target "paths" with type "example" omitted
+
+# Unsupported target "traits" with type "example" omitted
+
+# Unsupported target "versions" with type "example" omitted
+
+rust_library(
+    name = "autocfg",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "rustflags" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.13.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.13.0.bazel
new file mode 100644
index 0000000..3d3ee34
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.13.0.bazel
@@ -0,0 +1,69 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmarks" with type "bench" omitted
+
+# Unsupported target "base64" with type "example" omitted
+
+# Unsupported target "make_tables" with type "example" omitted
+
+rust_library(
+    name = "base64",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.13.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "decode" with type "test" omitted
+
+# Unsupported target "encode" with type "test" omitted
+
+# Unsupported target "helpers" with type "test" omitted
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.9.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.9.3.bazel
new file mode 100644
index 0000000..a783db7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.base64-0.9.3.bazel
@@ -0,0 +1,67 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmarks" with type "bench" omitted
+
+# Unsupported target "make_tables" with type "example" omitted
+
+rust_library(
+    name = "base64",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__byteorder__1_4_3//:byteorder",
+        "@rules_rust_wasm_bindgen__safemem__0_3_3//:safemem",
+    ],
+)
+
+# Unsupported target "decode" with type "test" omitted
+
+# Unsupported target "encode" with type "test" omitted
+
+# Unsupported target "helpers" with type "test" omitted
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bazel
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bazel
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bitflags-1.3.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bitflags-1.3.2.bazel
new file mode 100644
index 0000000..18f2842
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bitflags-1.3.2.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "bitflags",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.3.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "basic" with type "test" omitted
+
+# Unsupported target "compile" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bstr-0.2.17.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bstr-0.2.17.bazel
new file mode 100644
index 0000000..41ce46f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bstr-0.2.17.bazel
@@ -0,0 +1,77 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "graphemes" with type "example" omitted
+
+# Unsupported target "graphemes-std" with type "example" omitted
+
+# Unsupported target "lines" with type "example" omitted
+
+# Unsupported target "lines-std" with type "example" omitted
+
+# Unsupported target "uppercase" with type "example" omitted
+
+# Unsupported target "uppercase-std" with type "example" omitted
+
+# Unsupported target "words" with type "example" omitted
+
+# Unsupported target "words-std" with type "example" omitted
+
+rust_library(
+    name = "bstr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "regex-automata",
+        "std",
+        "unicode",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.17",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__memchr__2_4_1//:memchr",
+        "@rules_rust_wasm_bindgen__regex_automata__0_1_10//:regex_automata",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.buf_redux-0.8.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.buf_redux-0.8.4.bazel
new file mode 100644
index 0000000..a8c0ed7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.buf_redux-0.8.4.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "buf_redux",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__memchr__2_4_1//:memchr",
+        "@rules_rust_wasm_bindgen__safemem__0_3_3//:safemem",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bumpalo-3.8.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bumpalo-3.8.0.bazel
new file mode 100644
index 0000000..67578ad
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.bumpalo-3.8.0.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+rust_library(
+    name = "bumpalo",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "3.8.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "try_alloc" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.byteorder-1.4.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.byteorder-1.4.3.bazel
new file mode 100644
index 0000000..9f319f2
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.byteorder-1.4.3.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "byteorder",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cc-1.0.71.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cc-1.0.71.bazel
new file mode 100644
index 0000000..c604772
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cc-1.0.71.bazel
@@ -0,0 +1,85 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_gcc_shim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/gcc-shim.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.71",
+    # buildifier: leave-alone
+    deps = [
+        ":cc",
+    ],
+)
+
+rust_library(
+    name = "cc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.71",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "cc_env" with type "test" omitted
+
+# Unsupported target "cflags" with type "test" omitted
+
+# Unsupported target "cxxflags" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel
new file mode 100644
index 0000000..e4ad04f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.cfg-if-1.0.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "cfg_if",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "xcrate" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chrono-0.4.19.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chrono-0.4.19.bazel
new file mode 100644
index 0000000..49442e7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chrono-0.4.19.bazel
@@ -0,0 +1,77 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "chrono" with type "bench" omitted
+
+# Unsupported target "serde" with type "bench" omitted
+
+rust_library(
+    name = "chrono",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "clock",
+        "libc",
+        "std",
+        "winapi",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.19",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        "@rules_rust_wasm_bindgen__num_integer__0_1_44//:num_integer",
+        "@rules_rust_wasm_bindgen__num_traits__0_2_14//:num_traits",
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "wasm" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chunked_transfer-1.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chunked_transfer-1.4.0.bazel
new file mode 100644
index 0000000..b20b6f7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.chunked_transfer-1.4.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "encode" with type "bench" omitted
+
+rust_library(
+    name = "chunked_transfer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-channel-0.5.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-channel-0.5.1.bazel
new file mode 100644
index 0000000..0462551
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-channel-0.5.1.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "crossbeam" with type "bench" omitted
+
+# Unsupported target "fibonacci" with type "example" omitted
+
+# Unsupported target "matching" with type "example" omitted
+
+# Unsupported target "stopwatch" with type "example" omitted
+
+rust_library(
+    name = "crossbeam_channel",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "crossbeam-utils",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.5.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+        "@rules_rust_wasm_bindgen__crossbeam_utils__0_8_5//:crossbeam_utils",
+    ],
+)
+
+# Unsupported target "after" with type "test" omitted
+
+# Unsupported target "array" with type "test" omitted
+
+# Unsupported target "golang" with type "test" omitted
+
+# Unsupported target "iter" with type "test" omitted
+
+# Unsupported target "list" with type "test" omitted
+
+# Unsupported target "mpsc" with type "test" omitted
+
+# Unsupported target "never" with type "test" omitted
+
+# Unsupported target "ready" with type "test" omitted
+
+# Unsupported target "same_channel" with type "test" omitted
+
+# Unsupported target "select" with type "test" omitted
+
+# Unsupported target "select_macro" with type "test" omitted
+
+# Unsupported target "thread_locals" with type "test" omitted
+
+# Unsupported target "tick" with type "test" omitted
+
+# Unsupported target "zero" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-deque-0.8.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-deque-0.8.1.bazel
new file mode 100644
index 0000000..45ae4b4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-deque-0.8.1.bazel
@@ -0,0 +1,68 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "crossbeam_deque",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "crossbeam-epoch",
+        "crossbeam-utils",
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+        "@rules_rust_wasm_bindgen__crossbeam_epoch__0_9_5//:crossbeam_epoch",
+        "@rules_rust_wasm_bindgen__crossbeam_utils__0_8_5//:crossbeam_utils",
+    ],
+)
+
+# Unsupported target "fifo" with type "test" omitted
+
+# Unsupported target "injector" with type "test" omitted
+
+# Unsupported target "lifo" with type "test" omitted
+
+# Unsupported target "steal" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-epoch-0.9.5.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-epoch-0.9.5.bazel
new file mode 100644
index 0000000..9407fd0
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-epoch-0.9.5.bazel
@@ -0,0 +1,104 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "crossbeam_epoch_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "alloc",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "defer" with type "bench" omitted
+
+# Unsupported target "flush" with type "bench" omitted
+
+# Unsupported target "pin" with type "bench" omitted
+
+# Unsupported target "sanitize" with type "example" omitted
+
+rust_library(
+    name = "crossbeam_epoch",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.5",
+    # buildifier: leave-alone
+    deps = [
+        ":crossbeam_epoch_build_script",
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+        "@rules_rust_wasm_bindgen__crossbeam_utils__0_8_5//:crossbeam_utils",
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__memoffset__0_6_4//:memoffset",
+        "@rules_rust_wasm_bindgen__scopeguard__1_1_0//:scopeguard",
+    ],
+)
+
+# Unsupported target "loom" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-utils-0.8.5.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-utils-0.8.5.bazel
new file mode 100644
index 0000000..716dcf0
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.crossbeam-utils-0.8.5.bazel
@@ -0,0 +1,105 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "crossbeam_utils_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "atomic_cell" with type "bench" omitted
+
+rust_library(
+    name = "crossbeam_utils",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "lazy_static",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.5",
+    # buildifier: leave-alone
+    deps = [
+        ":crossbeam_utils_build_script",
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+    ],
+)
+
+# Unsupported target "atomic_cell" with type "test" omitted
+
+# Unsupported target "cache_padded" with type "test" omitted
+
+# Unsupported target "parker" with type "test" omitted
+
+# Unsupported target "sharded_lock" with type "test" omitted
+
+# Unsupported target "thread" with type "test" omitted
+
+# Unsupported target "wait_group" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-0.4.40.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-0.4.40.bazel
new file mode 100644
index 0000000..b2f328f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-0.4.40.bazel
@@ -0,0 +1,172 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "curl_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "openssl-probe",
+        "openssl-sys",
+        "ssl",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.40",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__curl_sys__0_4_50_curl_7_79_1//:curl_sys",
+    ] + selects.with_or({
+        # cfg(all(unix, not(target_os = "macos")))
+        (
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__openssl_sys__0_9_70//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "aws_sigv4" with type "example" omitted
+
+# Unsupported target "ssl_cert_blob" with type "example" omitted
+
+# Unsupported target "ssl_proxy" with type "example" omitted
+
+rust_library(
+    name = "curl",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "default",
+        "openssl-probe",
+        "openssl-sys",
+        "ssl",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.40",
+    # buildifier: leave-alone
+    deps = [
+        ":curl_build_script",
+        "@rules_rust_wasm_bindgen__curl_sys__0_4_50_curl_7_79_1//:curl_sys",
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        "@rules_rust_wasm_bindgen__socket2__0_4_2//:socket2",
+    ] + selects.with_or({
+        # cfg(all(unix, not(target_os = "macos")))
+        (
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__openssl_probe__0_1_4//:openssl_probe",
+            "@rules_rust_wasm_bindgen__openssl_sys__0_9_70//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__schannel__0_1_19//:schannel",
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "atexit" with type "test" omitted
+
+# Unsupported target "easy" with type "test" omitted
+
+# Unsupported target "multi" with type "test" omitted
+
+# Unsupported target "post" with type "test" omitted
+
+# Unsupported target "protocols" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-sys-0.4.50+curl-7.79.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-sys-0.4.50+curl-7.79.1.bazel
new file mode 100644
index 0000000..1b9d3ad
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.curl-sys-0.4.50+curl-7.79.1.bazel
@@ -0,0 +1,98 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-build" with type "custom-build" omitted
+
+rust_library(
+    name = "curl_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "openssl-sys",
+        "ssl",
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.50+curl-7.79.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        "@rules_rust_wasm_bindgen__libz_sys__1_1_3//:libz_sys",
+    ] + selects.with_or({
+        # cfg(all(unix, not(target_os = "macos")))
+        (
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__openssl_sys__0_9_70//:openssl_sys",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.diff-0.1.12.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.diff-0.1.12.bazel
new file mode 100644
index 0000000..69044d0
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.diff-0.1.12.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+# Unsupported target "simple" with type "example" omitted
+
+rust_library(
+    name = "diff",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.12",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difference-2.0.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difference-2.0.0.bazel
new file mode 100644
index 0000000..a03ad9b
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difference-2.0.0.bazel
@@ -0,0 +1,87 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_difference",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/main.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.0",
+    # buildifier: leave-alone
+    deps = [
+        ":difference",
+    ],
+)
+
+# Unsupported target "github-style" with type "example" omitted
+
+# Unsupported target "line-by-line" with type "example" omitted
+
+# Unsupported target "underline-words" with type "example" omitted
+
+rust_library(
+    name = "difference",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "quickcheck" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difflib-0.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difflib-0.4.0.bazel
new file mode 100644
index 0000000..c7bd8e3
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.difflib-0.4.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "example" with type "example" omitted
+
+rust_library(
+    name = "difflib",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.doc-comment-0.3.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.doc-comment-0.3.3.bazel
new file mode 100644
index 0000000..7449ccb
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.doc-comment-0.3.3.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "doc_comment_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "doc_comment",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+        ":doc_comment_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.docopt-1.1.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.docopt-1.1.1.bazel
new file mode 100644
index 0000000..a26ee56
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.docopt-1.1.1.bazel
@@ -0,0 +1,97 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_docopt_wordlist",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/wordlist.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.1",
+    # buildifier: leave-alone
+    deps = [
+        ":docopt",
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__strsim__0_10_0//:strsim",
+    ],
+)
+
+# Unsupported target "cargo" with type "example" omitted
+
+# Unsupported target "cp" with type "example" omitted
+
+# Unsupported target "decode" with type "example" omitted
+
+# Unsupported target "hashmap" with type "example" omitted
+
+# Unsupported target "optional_command" with type "example" omitted
+
+# Unsupported target "verbose_multiple" with type "example" omitted
+
+rust_library(
+    name = "docopt",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__strsim__0_10_0//:strsim",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.either-1.6.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.either-1.6.1.bazel
new file mode 100644
index 0000000..4d704c6
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.either-1.6.1.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "either",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.6.1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.env_logger-0.8.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.env_logger-0.8.4.bazel
new file mode 100644
index 0000000..d75f156
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.env_logger-0.8.4.bazel
@@ -0,0 +1,71 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "env_logger",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "atty",
+        "default",
+        "humantime",
+        "regex",
+        "termcolor",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__atty__0_2_14//:atty",
+        "@rules_rust_wasm_bindgen__humantime__2_1_0//:humantime",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__regex__1_5_4//:regex",
+        "@rules_rust_wasm_bindgen__termcolor__1_1_2//:termcolor",
+    ],
+)
+
+# Unsupported target "init-twice-retains-filter" with type "test" omitted
+
+# Unsupported target "log-in-log" with type "test" omitted
+
+# Unsupported target "log_tls_dtors" with type "test" omitted
+
+# Unsupported target "regexp_filter" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.filetime-0.2.15.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.filetime-0.2.15.bazel
new file mode 100644
index 0000000..9c0c8e4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.filetime-0.2.15.bazel
@@ -0,0 +1,88 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "filetime",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.15",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.float-cmp-0.8.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.float-cmp-0.8.0.bazel
new file mode 100644
index 0000000..3792860
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.float-cmp-0.8.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "float_cmp",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "num-traits",
+        "ratio",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__num_traits__0_2_14//:num_traits",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.form_urlencoded-1.0.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.form_urlencoded-1.0.1.bazel
new file mode 100644
index 0000000..5b7860a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.form_urlencoded-1.0.1.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "form_urlencoded",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__matches__0_1_9//:matches",
+        "@rules_rust_wasm_bindgen__percent_encoding__2_1_0//:percent_encoding",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.getrandom-0.2.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.getrandom-0.2.3.bazel
new file mode 100644
index 0000000..2b8513e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.getrandom-0.2.3.bazel
@@ -0,0 +1,96 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "mod" with type "bench" omitted
+
+rust_library(
+    name = "getrandom",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+    ] + selects.with_or({
+        # cfg(target_os = "wasi")
+        (
+            "@rules_rust//rust/platform:wasm32-wasi",
+        ): [
+            "@rules_rust_wasm_bindgen__wasi__0_10_2_wasi_snapshot_preview1//:wasi",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "custom" with type "test" omitted
+
+# Unsupported target "normal" with type "test" omitted
+
+# Unsupported target "rdrand" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.heck-0.3.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.heck-0.3.3.bazel
new file mode 100644
index 0000000..29ce668
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.heck-0.3.3.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "heck",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__unicode_segmentation__1_8_0//:unicode_segmentation",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.hermit-abi-0.1.19.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.hermit-abi-0.1.19.bazel
new file mode 100644
index 0000000..30a717d
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.hermit-abi-0.1.19.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "hermit_abi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.19",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.httparse-1.5.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.httparse-1.5.1.bazel
new file mode 100644
index 0000000..c27995e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.httparse-1.5.1.bazel
@@ -0,0 +1,91 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "httparse_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "parse" with type "bench" omitted
+
+rust_library(
+    name = "httparse",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.1",
+    # buildifier: leave-alone
+    deps = [
+        ":httparse_build_script",
+    ],
+)
+
+# Unsupported target "uri" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.humantime-2.1.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.humantime-2.1.0.bazel
new file mode 100644
index 0000000..2ed8303
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.humantime-2.1.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "datetime_format" with type "bench" omitted
+
+# Unsupported target "datetime_parse" with type "bench" omitted
+
+rust_library(
+    name = "humantime",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.id-arena-2.2.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.id-arena-2.2.1.bazel
new file mode 100644
index 0000000..d3cf8e7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.id-arena-2.2.1.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "id_arena",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "rayon",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.2.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__rayon__1_5_1//:rayon",
+    ],
+)
+
+# Unsupported target "readme_up_to_date" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.idna-0.2.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.idna-0.2.3.bazel
new file mode 100644
index 0000000..2b4d3f7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.idna-0.2.3.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "all" with type "bench" omitted
+
+rust_library(
+    name = "idna",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__matches__0_1_9//:matches",
+        "@rules_rust_wasm_bindgen__unicode_bidi__0_3_7//:unicode_bidi",
+        "@rules_rust_wasm_bindgen__unicode_normalization__0_1_19//:unicode_normalization",
+    ],
+)
+
+# Unsupported target "tests" with type "test" omitted
+
+# Unsupported target "unit" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itertools-0.10.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itertools-0.10.1.bazel
new file mode 100644
index 0000000..757cfc7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itertools-0.10.1.bazel
@@ -0,0 +1,99 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench1" with type "bench" omitted
+
+# Unsupported target "combinations" with type "bench" omitted
+
+# Unsupported target "combinations_with_replacement" with type "bench" omitted
+
+# Unsupported target "fold_specialization" with type "bench" omitted
+
+# Unsupported target "powerset" with type "bench" omitted
+
+# Unsupported target "tree_fold1" with type "bench" omitted
+
+# Unsupported target "tuple_combinations" with type "bench" omitted
+
+# Unsupported target "tuples" with type "bench" omitted
+
+# Unsupported target "iris" with type "example" omitted
+
+rust_library(
+    name = "itertools",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "use_alloc",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__either__1_6_1//:either",
+    ],
+)
+
+# Unsupported target "adaptors_no_collect" with type "test" omitted
+
+# Unsupported target "flatten_ok" with type "test" omitted
+
+# Unsupported target "fold_specialization" with type "test" omitted
+
+# Unsupported target "macros_hygiene" with type "test" omitted
+
+# Unsupported target "merge_join" with type "test" omitted
+
+# Unsupported target "peeking_take_while" with type "test" omitted
+
+# Unsupported target "quick" with type "test" omitted
+
+# Unsupported target "specializations" with type "test" omitted
+
+# Unsupported target "test_core" with type "test" omitted
+
+# Unsupported target "test_std" with type "test" omitted
+
+# Unsupported target "tuples" with type "test" omitted
+
+# Unsupported target "zip" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itoa-0.4.8.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itoa-0.4.8.bazel
new file mode 100644
index 0000000..9737226
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.itoa-0.4.8.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "itoa",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.8",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel
new file mode 100644
index 0000000..cb09d1a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.lazy_static-1.4.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "lazy_static",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.4.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "no_std" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.leb128-0.2.5.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.leb128-0.2.5.bazel
new file mode 100644
index 0000000..a4721fb
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.leb128-0.2.5.bazel
@@ -0,0 +1,81 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_leb128_repl",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/leb128-repl.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.5",
+    # buildifier: leave-alone
+    deps = [
+        ":leb128",
+    ],
+)
+
+rust_library(
+    name = "leb128",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.5",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "quickchecks" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libc-0.2.107.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libc-0.2.107.bazel
new file mode 100644
index 0000000..8f54ee4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libc-0.2.107.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libc_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.107",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "libc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.107",
+    # buildifier: leave-alone
+    deps = [
+        ":libc_build_script",
+    ],
+)
+
+# Unsupported target "const_fn" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libz-sys-1.1.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libz-sys-1.1.3.bazel
new file mode 100644
index 0000000..aa4a3ba
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.libz-sys-1.1.3.bazel
@@ -0,0 +1,108 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "libz_sys_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "libc",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    links = "z",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.3",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__cc__1_0_71//:cc",
+        "@rules_rust_wasm_bindgen__pkg_config__0_3_22//:pkg_config",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__vcpkg__0_2_15//:vcpkg",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "libz_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "libc",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.3",
+    # buildifier: leave-alone
+    deps = [
+        ":libz_sys_build_script",
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.log-0.4.14.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.log-0.4.14.bazel
new file mode 100644
index 0000000..a58bb2f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.log-0.4.14.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "log_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "value" with type "bench" omitted
+
+rust_library(
+    name = "log",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=atomic_cas",
+        "--cfg=use_std",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.14",
+    # buildifier: leave-alone
+    deps = [
+        ":log_build_script",
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "filters" with type "test" omitted
+
+# Unsupported target "macros" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.matches-0.1.9.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.matches-0.1.9.bazel
new file mode 100644
index 0000000..f31e188
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.matches-0.1.9.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "matches",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.9",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "macro_use_one" with type "test" omitted
+
+# Unsupported target "use_star" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memchr-2.4.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memchr-2.4.1.bazel
new file mode 100644
index 0000000..69c467f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memchr-2.4.1.bazel
@@ -0,0 +1,89 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "memchr_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+        "use_std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "memchr",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.4.1",
+    # buildifier: leave-alone
+    deps = [
+        ":memchr_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memoffset-0.6.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memoffset-0.6.4.bazel
new file mode 100644
index 0000000..24bb16e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.memoffset-0.6.4.bazel
@@ -0,0 +1,86 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "memoffset_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.4",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__autocfg__1_0_1//:autocfg",
+    ],
+)
+
+rust_library(
+    name = "memoffset",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.4",
+    # buildifier: leave-alone
+    deps = [
+        ":memoffset_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime-0.3.16.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime-0.3.16.bazel
new file mode 100644
index 0000000..adfd28a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime-0.3.16.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "cmp" with type "bench" omitted
+
+# Unsupported target "fmt" with type "bench" omitted
+
+# Unsupported target "parse" with type "bench" omitted
+
+rust_library(
+    name = "mime",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.16",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime_guess-2.0.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime_guess-2.0.3.bazel
new file mode 100644
index 0000000..60bb34c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.mime_guess-2.0.3.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "mime_guess_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "rev-mappings",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.3",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__unicase__2_6_0//:unicase",
+    ],
+)
+
+# Unsupported target "benchmark" with type "bench" omitted
+
+# Unsupported target "rev_map" with type "example" omitted
+
+rust_library(
+    name = "mime_guess",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "rev-mappings",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.3",
+    # buildifier: leave-alone
+    deps = [
+        ":mime_guess_build_script",
+        "@rules_rust_wasm_bindgen__mime__0_3_16//:mime",
+        "@rules_rust_wasm_bindgen__unicase__2_6_0//:unicase",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.multipart-0.18.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.multipart-0.18.0.bazel
new file mode 100644
index 0000000..ff3351e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.multipart-0.18.0.bazel
@@ -0,0 +1,125 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_form_test",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "buf_redux",
+        "httparse",
+        "quick-error",
+        "safemem",
+        "server",
+        "twoway",
+    ],
+    crate_root = "src/bin/form_test.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.18.0",
+    # buildifier: leave-alone
+    deps = [
+        ":multipart",
+        "@rules_rust_wasm_bindgen__buf_redux__0_8_4//:buf_redux",
+        "@rules_rust_wasm_bindgen__httparse__1_5_1//:httparse",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__mime__0_3_16//:mime",
+        "@rules_rust_wasm_bindgen__mime_guess__2_0_3//:mime_guess",
+        "@rules_rust_wasm_bindgen__quick_error__1_2_3//:quick_error",
+        "@rules_rust_wasm_bindgen__rand__0_8_4//:rand",
+        "@rules_rust_wasm_bindgen__safemem__0_3_3//:safemem",
+        "@rules_rust_wasm_bindgen__tempfile__3_2_0//:tempfile",
+        "@rules_rust_wasm_bindgen__twoway__0_1_8//:twoway",
+    ],
+)
+
+# Unsupported target "hyper_client" with type "example" omitted
+
+# Unsupported target "hyper_reqbuilder" with type "example" omitted
+
+# Unsupported target "hyper_server" with type "example" omitted
+
+# Unsupported target "iron" with type "example" omitted
+
+# Unsupported target "iron_intercept" with type "example" omitted
+
+# Unsupported target "nickel" with type "example" omitted
+
+# Unsupported target "rocket" with type "example" omitted
+
+# Unsupported target "tiny_http" with type "example" omitted
+
+rust_library(
+    name = "multipart",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "buf_redux",
+        "httparse",
+        "quick-error",
+        "safemem",
+        "server",
+        "twoway",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.18.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__buf_redux__0_8_4//:buf_redux",
+        "@rules_rust_wasm_bindgen__httparse__1_5_1//:httparse",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__mime__0_3_16//:mime",
+        "@rules_rust_wasm_bindgen__mime_guess__2_0_3//:mime_guess",
+        "@rules_rust_wasm_bindgen__quick_error__1_2_3//:quick_error",
+        "@rules_rust_wasm_bindgen__rand__0_8_4//:rand",
+        "@rules_rust_wasm_bindgen__safemem__0_3_3//:safemem",
+        "@rules_rust_wasm_bindgen__tempfile__3_2_0//:tempfile",
+        "@rules_rust_wasm_bindgen__twoway__0_1_8//:twoway",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.normalize-line-endings-0.3.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.normalize-line-endings-0.3.0.bazel
new file mode 100644
index 0000000..03c0389
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.normalize-line-endings-0.3.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "normalize_line_endings",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-integer-0.1.44.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-integer-0.1.44.bazel
new file mode 100644
index 0000000..1052c08
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-integer-0.1.44.bazel
@@ -0,0 +1,95 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "num_integer_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.44",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__autocfg__1_0_1//:autocfg",
+    ],
+)
+
+# Unsupported target "average" with type "bench" omitted
+
+# Unsupported target "gcd" with type "bench" omitted
+
+# Unsupported target "roots" with type "bench" omitted
+
+rust_library(
+    name = "num_integer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.44",
+    # buildifier: leave-alone
+    deps = [
+        ":num_integer_build_script",
+        "@rules_rust_wasm_bindgen__num_traits__0_2_14//:num_traits",
+    ],
+)
+
+# Unsupported target "average" with type "test" omitted
+
+# Unsupported target "roots" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-traits-0.2.14.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-traits-0.2.14.bazel
new file mode 100644
index 0000000..7532249
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num-traits-0.2.14.bazel
@@ -0,0 +1,86 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "num_traits_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.14",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__autocfg__1_0_1//:autocfg",
+    ],
+)
+
+rust_library(
+    name = "num_traits",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.14",
+    # buildifier: leave-alone
+    deps = [
+        ":num_traits_build_script",
+    ],
+)
+
+# Unsupported target "cast" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num_cpus-1.13.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num_cpus-1.13.0.bazel
new file mode 100644
index 0000000..abca5ea
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.num_cpus-1.13.0.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "values" with type "example" omitted
+
+rust_library(
+    name = "num_cpus",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.13.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-probe-0.1.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-probe-0.1.4.bazel
new file mode 100644
index 0000000..7583d6c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-probe-0.1.4.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "openssl_probe",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.4",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-sys-0.9.70.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-sys-0.9.70.bazel
new file mode 100644
index 0000000..2024b3d
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.openssl-sys-0.9.70.bazel
@@ -0,0 +1,79 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "build-script-main" with type "custom-build" omitted
+
+rust_library(
+    name = "openssl_sys",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=ossl101",
+        "--cfg=ossl102",
+        "--cfg=ossl102f",
+        "--cfg=ossl102h",
+        "--cfg=ossl110",
+        "--cfg=ossl110f",
+        "--cfg=ossl110g",
+        "--cfg=ossl111",
+        "--cfg=ossl111b",
+        "-l",
+        "dylib=ssl",
+        "-l",
+        "dylib=crypto",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.70",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+    ] + selects.with_or({
+        # cfg(target_env = "msvc")
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.percent-encoding-2.1.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.percent-encoding-2.1.0.bazel
new file mode 100644
index 0000000..c791a19
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.percent-encoding-2.1.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "percent_encoding",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.pkg-config-0.3.22.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.pkg-config-0.3.22.bazel
new file mode 100644
index 0000000..0d4ccef
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.pkg-config-0.3.22.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "pkg_config",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.22",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ppv-lite86-0.2.15.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ppv-lite86-0.2.15.bazel
new file mode 100644
index 0000000..843ee59
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ppv-lite86-0.2.15.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "ppv_lite86",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "simd",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.15",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-1.0.8.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-1.0.8.bazel
new file mode 100644
index 0000000..49ffdbd
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-1.0.8.bazel
@@ -0,0 +1,65 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "case_tree" with type "example" omitted
+
+rust_library(
+    name = "predicates",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "difference",
+        "float-cmp",
+        "normalize-line-endings",
+        "regex",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.8",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__difference__2_0_0//:difference",
+        "@rules_rust_wasm_bindgen__float_cmp__0_8_0//:float_cmp",
+        "@rules_rust_wasm_bindgen__normalize_line_endings__0_3_0//:normalize_line_endings",
+        "@rules_rust_wasm_bindgen__predicates_core__1_0_2//:predicates_core",
+        "@rules_rust_wasm_bindgen__regex__1_5_4//:regex",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-2.0.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-2.0.3.bazel
new file mode 100644
index 0000000..01a3dcb
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-2.0.3.bazel
@@ -0,0 +1,60 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "case_tree" with type "example" omitted
+
+rust_library(
+    name = "predicates",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "diff",
+        "difflib",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.0.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__difflib__0_4_0//:difflib",
+        "@rules_rust_wasm_bindgen__itertools__0_10_1//:itertools",
+        "@rules_rust_wasm_bindgen__predicates_core__1_0_2//:predicates_core",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-core-1.0.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-core-1.0.2.bazel
new file mode 100644
index 0000000..a5d5643
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-core-1.0.2.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "predicates_core",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-tree-1.0.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-tree-1.0.4.bazel
new file mode 100644
index 0000000..3a2eea6
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.predicates-tree-1.0.4.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "failures" with type "example" omitted
+
+rust_library(
+    name = "predicates_tree",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__predicates_core__1_0_2//:predicates_core",
+        "@rules_rust_wasm_bindgen__termtree__0_2_3//:termtree",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.proc-macro2-1.0.32.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.proc-macro2-1.0.32.bazel
new file mode 100644
index 0000000..2f4799f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.proc-macro2-1.0.32.bazel
@@ -0,0 +1,99 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "proc_macro2_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.32",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "proc_macro2",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=use_proc_macro",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.32",
+    # buildifier: leave-alone
+    deps = [
+        ":proc_macro2_build_script",
+        "@rules_rust_wasm_bindgen__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "comments" with type "test" omitted
+
+# Unsupported target "features" with type "test" omitted
+
+# Unsupported target "marker" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
+
+# Unsupported target "test_fmt" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quick-error-1.2.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quick-error-1.2.3.bazel
new file mode 100644
index 0000000..d528050
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quick-error-1.2.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "context" with type "example" omitted
+
+rust_library(
+    name = "quick_error",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.2.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quote-1.0.10.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quote-1.0.10.bazel
new file mode 100644
index 0000000..8db384e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.quote-1.0.10.bazel
@@ -0,0 +1,62 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "quote",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "proc-macro",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.10",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+    ],
+)
+
+# Unsupported target "compiletest" with type "test" omitted
+
+# Unsupported target "test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand-0.8.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand-0.8.4.bazel
new file mode 100644
index 0000000..795e889
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand-0.8.4.bazel
@@ -0,0 +1,114 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+        "alloc",
+        "default",
+        "getrandom",
+        "libc",
+        "rand_chacha",
+        "rand_hc",
+        "std",
+        "std_rng",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__rand_core__0_6_3//:rand_core",
+    ] + selects.with_or({
+        # cfg(not(target_os = "emscripten"))
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:wasm32-unknown-unknown",
+            "@rules_rust//rust/platform:wasm32-wasi",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__rand_chacha__0_3_1//:rand_chacha",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_chacha-0.3.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_chacha-0.3.1.bazel
new file mode 100644
index 0000000..ca21d12
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_chacha-0.3.1.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand_chacha",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__ppv_lite86__0_2_15//:ppv_lite86",
+        "@rules_rust_wasm_bindgen__rand_core__0_6_3//:rand_core",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_core-0.6.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_core-0.6.3.bazel
new file mode 100644
index 0000000..b8f563d
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_core-0.6.3.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand_core",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "getrandom",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.3",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__getrandom__0_2_3//:getrandom",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_hc-0.3.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_hc-0.3.1.bazel
new file mode 100644
index 0000000..0812602
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rand_hc-0.3.1.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rand_hc",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__rand_core__0_6_3//:rand_core",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-1.5.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-1.5.1.bazel
new file mode 100644
index 0000000..d125b81
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-1.5.1.bazel
@@ -0,0 +1,117 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "rayon_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.1",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__autocfg__1_0_1//:autocfg",
+    ],
+)
+
+# Unsupported target "cpu_monitor" with type "example" omitted
+
+rust_library(
+    name = "rayon",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.1",
+    # buildifier: leave-alone
+    deps = [
+        ":rayon_build_script",
+        "@rules_rust_wasm_bindgen__crossbeam_deque__0_8_1//:crossbeam_deque",
+        "@rules_rust_wasm_bindgen__either__1_6_1//:either",
+        "@rules_rust_wasm_bindgen__rayon_core__1_9_1//:rayon_core",
+    ],
+)
+
+# Unsupported target "chars" with type "test" omitted
+
+# Unsupported target "clones" with type "test" omitted
+
+# Unsupported target "collect" with type "test" omitted
+
+# Unsupported target "cross-pool" with type "test" omitted
+
+# Unsupported target "debug" with type "test" omitted
+
+# Unsupported target "intersperse" with type "test" omitted
+
+# Unsupported target "issue671" with type "test" omitted
+
+# Unsupported target "issue671-unzip" with type "test" omitted
+
+# Unsupported target "iter_panic" with type "test" omitted
+
+# Unsupported target "named-threads" with type "test" omitted
+
+# Unsupported target "octillion" with type "test" omitted
+
+# Unsupported target "producer_split_at" with type "test" omitted
+
+# Unsupported target "sort-panic-safe" with type "test" omitted
+
+# Unsupported target "str" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-core-1.9.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-core-1.9.1.bazel
new file mode 100644
index 0000000..1b2754b
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rayon-core-1.9.1.bazel
@@ -0,0 +1,101 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR MIT"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "rayon_core_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    links = "rayon-core",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.9.1",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "rayon_core",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.9.1",
+    # buildifier: leave-alone
+    deps = [
+        ":rayon_core_build_script",
+        "@rules_rust_wasm_bindgen__crossbeam_channel__0_5_1//:crossbeam_channel",
+        "@rules_rust_wasm_bindgen__crossbeam_deque__0_8_1//:crossbeam_deque",
+        "@rules_rust_wasm_bindgen__crossbeam_utils__0_8_5//:crossbeam_utils",
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__num_cpus__1_13_0//:num_cpus",
+    ],
+)
+
+# Unsupported target "double_init_fail" with type "test" omitted
+
+# Unsupported target "init_zero_threads" with type "test" omitted
+
+# Unsupported target "scope_join" with type "test" omitted
+
+# Unsupported target "scoped_threadpool" with type "test" omitted
+
+# Unsupported target "simple_panic" with type "test" omitted
+
+# Unsupported target "stack_overflow_crash" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.redox_syscall-0.2.10.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.redox_syscall-0.2.10.bazel
new file mode 100644
index 0000000..572b544
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.redox_syscall-0.2.10.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+alias(
+    name = "redox_syscall",
+    actual = ":syscall",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
+rust_library(
+    name = "syscall",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.10",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__bitflags__1_3_2//:bitflags",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-1.5.4.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-1.5.4.bazel
new file mode 100644
index 0000000..d5527a9
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-1.5.4.bazel
@@ -0,0 +1,103 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "shootout-regex-dna" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-bytes" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-cheat" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-replace" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single" with type "example" omitted
+
+# Unsupported target "shootout-regex-dna-single-cheat" with type "example" omitted
+
+rust_library(
+    name = "regex",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.4",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__aho_corasick__0_7_18//:aho_corasick",
+        "@rules_rust_wasm_bindgen__memchr__2_4_1//:memchr",
+        "@rules_rust_wasm_bindgen__regex_syntax__0_6_25//:regex_syntax",
+    ],
+)
+
+# Unsupported target "backtrack" with type "test" omitted
+
+# Unsupported target "backtrack-bytes" with type "test" omitted
+
+# Unsupported target "backtrack-utf8bytes" with type "test" omitted
+
+# Unsupported target "crates-regex" with type "test" omitted
+
+# Unsupported target "default" with type "test" omitted
+
+# Unsupported target "default-bytes" with type "test" omitted
+
+# Unsupported target "nfa" with type "test" omitted
+
+# Unsupported target "nfa-bytes" with type "test" omitted
+
+# Unsupported target "nfa-utf8bytes" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-automata-0.1.10.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-automata-0.1.10.bazel
new file mode 100644
index 0000000..d11e49c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-automata-0.1.10.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "regex_automata",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.10",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "default" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel
new file mode 100644
index 0000000..cb10f74
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.regex-syntax-0.6.25.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "regex_syntax",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.25",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.remove_dir_all-0.5.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.remove_dir_all-0.5.3.bazel
new file mode 100644
index 0000000..4171bd3
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.remove_dir_all-0.5.3.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "remove_dir_all",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.5.3",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rouille-3.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rouille-3.4.0.bazel
new file mode 100644
index 0000000..92a917c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rouille-3.4.0.bazel
@@ -0,0 +1,88 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "database" with type "example" omitted
+
+# Unsupported target "git-http-backend" with type "example" omitted
+
+# Unsupported target "hello-world" with type "example" omitted
+
+# Unsupported target "login-session" with type "example" omitted
+
+# Unsupported target "php" with type "example" omitted
+
+# Unsupported target "reverse-proxy" with type "example" omitted
+
+# Unsupported target "simple-form" with type "example" omitted
+
+# Unsupported target "static-files" with type "example" omitted
+
+# Unsupported target "websocket" with type "example" omitted
+
+rust_library(
+    name = "rouille",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "3.4.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__base64__0_13_0//:base64",
+        "@rules_rust_wasm_bindgen__chrono__0_4_19//:chrono",
+        "@rules_rust_wasm_bindgen__filetime__0_2_15//:filetime",
+        "@rules_rust_wasm_bindgen__multipart__0_18_0//:multipart",
+        "@rules_rust_wasm_bindgen__num_cpus__1_13_0//:num_cpus",
+        "@rules_rust_wasm_bindgen__percent_encoding__2_1_0//:percent_encoding",
+        "@rules_rust_wasm_bindgen__rand__0_8_4//:rand",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+        "@rules_rust_wasm_bindgen__sha1__0_6_0//:sha1",
+        "@rules_rust_wasm_bindgen__threadpool__1_8_1//:threadpool",
+        "@rules_rust_wasm_bindgen__time__0_3_2//:time",
+        "@rules_rust_wasm_bindgen__tiny_http__0_8_2//:tiny_http",
+        "@rules_rust_wasm_bindgen__url__2_2_2//:url",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rustc-demangle-0.1.21.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rustc-demangle-0.1.21.bazel
new file mode 100644
index 0000000..1b985ba
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.rustc-demangle-0.1.21.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "rustc_demangle",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.21",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ryu-1.0.5.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ryu-1.0.5.bazel
new file mode 100644
index 0000000..f0f6478
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.ryu-1.0.5.bazel
@@ -0,0 +1,101 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR BSL-1.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "ryu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.5",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "bench" with type "bench" omitted
+
+# Unsupported target "upstream_benchmark" with type "example" omitted
+
+rust_library(
+    name = "ryu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.5",
+    # buildifier: leave-alone
+    deps = [
+        ":ryu_build_script",
+    ],
+)
+
+# Unsupported target "common_test" with type "test" omitted
+
+# Unsupported target "d2s_table_test" with type "test" omitted
+
+# Unsupported target "d2s_test" with type "test" omitted
+
+# Unsupported target "exhaustive" with type "test" omitted
+
+# Unsupported target "f2s_test" with type "test" omitted
+
+# Unsupported target "s2d_test" with type "test" omitted
+
+# Unsupported target "s2f_test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.safemem-0.3.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.safemem-0.3.3.bazel
new file mode 100644
index 0000000..294d28a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.safemem-0.3.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "safemem",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.schannel-0.1.19.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.schannel-0.1.19.bazel
new file mode 100644
index 0000000..4cd6525
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.schannel-0.1.19.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "schannel",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.19",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.scopeguard-1.1.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.scopeguard-1.1.0.bazel
new file mode 100644
index 0000000..eac55e3
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.scopeguard-1.1.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "readme" with type "example" omitted
+
+rust_library(
+    name = "scopeguard",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde-1.0.130.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde-1.0.130.bazel
new file mode 100644
index 0000000..851d77f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde-1.0.130.bazel
@@ -0,0 +1,94 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "derive",
+        "serde_derive",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "serde",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "derive",
+        "serde_derive",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_derive-1.0.130.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_derive-1.0.130.bazel
new file mode 100644
index 0000000..ffab3df
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_derive-1.0.130.bazel
@@ -0,0 +1,88 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_derive_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_proc_macro(
+    name = "serde_derive",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.130",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_derive_build_script",
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__syn__1_0_81//:syn",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_json-1.0.69.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_json-1.0.69.bazel
new file mode 100644
index 0000000..6446158
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.serde_json-1.0.69.bazel
@@ -0,0 +1,90 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "serde_json_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "serde_json",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.69",
+    # buildifier: leave-alone
+    deps = [
+        ":serde_json_build_script",
+        "@rules_rust_wasm_bindgen__itoa__0_4_8//:itoa",
+        "@rules_rust_wasm_bindgen__ryu__1_0_5//:ryu",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.sha1-0.6.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.sha1-0.6.0.bazel
new file mode 100644
index 0000000..d08acb1
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.sha1-0.6.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # BSD-3-Clause from expression "BSD-3-Clause"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "sha1",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.socket2-0.4.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.socket2-0.4.2.bazel
new file mode 100644
index 0000000..d407cf1
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.socket2-0.4.2.bazel
@@ -0,0 +1,87 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "socket2",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.2",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.strsim-0.10.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.strsim-0.10.0.bazel
new file mode 100644
index 0000000..79f33d0
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.strsim-0.10.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+rust_library(
+    name = "strsim",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "lib" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.syn-1.0.81.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.syn-1.0.81.bazel
new file mode 100644
index 0000000..96f181a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.syn-1.0.81.bazel
@@ -0,0 +1,162 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "syn_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.81",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+# Unsupported target "file" with type "bench" omitted
+
+# Unsupported target "rust" with type "bench" omitted
+
+rust_library(
+    name = "syn",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "clone-impls",
+        "default",
+        "derive",
+        "extra-traits",
+        "full",
+        "parsing",
+        "printing",
+        "proc-macro",
+        "quote",
+        "visit",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.0.81",
+    # buildifier: leave-alone
+    deps = [
+        ":syn_build_script",
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__unicode_xid__0_2_2//:unicode_xid",
+    ],
+)
+
+# Unsupported target "test_asyncness" with type "test" omitted
+
+# Unsupported target "test_attribute" with type "test" omitted
+
+# Unsupported target "test_derive_input" with type "test" omitted
+
+# Unsupported target "test_expr" with type "test" omitted
+
+# Unsupported target "test_generics" with type "test" omitted
+
+# Unsupported target "test_grouping" with type "test" omitted
+
+# Unsupported target "test_ident" with type "test" omitted
+
+# Unsupported target "test_item" with type "test" omitted
+
+# Unsupported target "test_iterators" with type "test" omitted
+
+# Unsupported target "test_lit" with type "test" omitted
+
+# Unsupported target "test_meta" with type "test" omitted
+
+# Unsupported target "test_parse_buffer" with type "test" omitted
+
+# Unsupported target "test_parse_stream" with type "test" omitted
+
+# Unsupported target "test_pat" with type "test" omitted
+
+# Unsupported target "test_path" with type "test" omitted
+
+# Unsupported target "test_precedence" with type "test" omitted
+
+# Unsupported target "test_receiver" with type "test" omitted
+
+# Unsupported target "test_round_trip" with type "test" omitted
+
+# Unsupported target "test_shebang" with type "test" omitted
+
+# Unsupported target "test_should_parse" with type "test" omitted
+
+# Unsupported target "test_size" with type "test" omitted
+
+# Unsupported target "test_stmt" with type "test" omitted
+
+# Unsupported target "test_token_trees" with type "test" omitted
+
+# Unsupported target "test_ty" with type "test" omitted
+
+# Unsupported target "test_visibility" with type "test" omitted
+
+# Unsupported target "zzz_stable" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tempfile-3.2.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tempfile-3.2.0.bazel
new file mode 100644
index 0000000..10cef58
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tempfile-3.2.0.bazel
@@ -0,0 +1,98 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tempfile",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "3.2.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+        "@rules_rust_wasm_bindgen__rand__0_8_4//:rand",
+        "@rules_rust_wasm_bindgen__remove_dir_all__0_5_3//:remove_dir_all",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }) + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "namedtempfile" with type "test" omitted
+
+# Unsupported target "spooled" with type "test" omitted
+
+# Unsupported target "tempdir" with type "test" omitted
+
+# Unsupported target "tempfile" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel
new file mode 100644
index 0000000..5d755f1
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termcolor-1.1.2.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "termcolor",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.1.2",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi_util__0_1_5//:winapi_util",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termtree-0.2.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termtree-0.2.3.bazel
new file mode 100644
index 0000000..8392103
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.termtree-0.2.3.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT"
+])
+
+# Generated Targets
+
+# Unsupported target "tree" with type "example" omitted
+
+rust_library(
+    name = "termtree",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.threadpool-1.8.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.threadpool-1.8.1.bazel
new file mode 100644
index 0000000..5063471
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.threadpool-1.8.1.bazel
@@ -0,0 +1,54 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "threadpool",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.8.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__num_cpus__1_13_0//:num_cpus",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.time-0.3.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.time-0.3.2.bazel
new file mode 100644
index 0000000..19f68bb
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.time-0.3.2.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmarks" with type "bench" omitted
+
+rust_library(
+    name = "time",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "default",
+        "local-offset",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tiny_http-0.8.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tiny_http-0.8.2.bazel
new file mode 100644
index 0000000..b961910
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tiny_http-0.8.2.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+# Unsupported target "hello-world" with type "example" omitted
+
+# Unsupported target "php-cgi" with type "example" omitted
+
+# Unsupported target "readme-example" with type "example" omitted
+
+# Unsupported target "serve-root" with type "example" omitted
+
+# Unsupported target "ssl" with type "example" omitted
+
+# Unsupported target "websockets" with type "example" omitted
+
+rust_library(
+    name = "tiny_http",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__ascii__1_0_0//:ascii",
+        "@rules_rust_wasm_bindgen__chrono__0_4_19//:chrono",
+        "@rules_rust_wasm_bindgen__chunked_transfer__1_4_0//:chunked_transfer",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__url__2_2_2//:url",
+    ],
+)
+
+# Unsupported target "input-tests" with type "test" omitted
+
+# Unsupported target "network" with type "test" omitted
+
+# Unsupported target "non-chunked-buffering" with type "test" omitted
+
+# Unsupported target "simple-test" with type "test" omitted
+
+# Unsupported target "unblock-test" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec-1.5.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec-1.5.0.bazel
new file mode 100644
index 0000000..7ffd979
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec-1.5.0.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Zlib from expression "Zlib OR (Apache-2.0 OR MIT)"
+])
+
+# Generated Targets
+
+# Unsupported target "macros" with type "bench" omitted
+
+rust_library(
+    name = "tinyvec",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "alloc",
+        "default",
+        "tinyvec_macros",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.5.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__tinyvec_macros__0_1_0//:tinyvec_macros",
+    ],
+)
+
+# Unsupported target "arrayvec" with type "test" omitted
+
+# Unsupported target "tinyvec" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel
new file mode 100644
index 0000000..48a87b3
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.tinyvec_macros-0.1.0.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR (Apache-2.0 OR Zlib)"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "tinyvec_macros",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.twoway-0.1.8.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.twoway-0.1.8.bazel
new file mode 100644
index 0000000..d120bdc
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.twoway-0.1.8.bazel
@@ -0,0 +1,60 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "pathology" with type "bench" omitted
+
+rust_library(
+    name = "twoway",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "use_std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.8",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__memchr__2_4_1//:memchr",
+    ],
+)
+
+# Unsupported target "quick" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicase-2.6.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicase-2.6.0.bazel
new file mode 100644
index 0000000..f04e0fd
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicase-2.6.0.bazel
@@ -0,0 +1,86 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "unicase_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.6.0",
+    visibility = ["//visibility:private"],
+    deps = [
+        "@rules_rust_wasm_bindgen__version_check__0_9_3//:version_check",
+    ],
+)
+
+rust_library(
+    name = "unicase",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+        "--cfg=__unicase__iter_cmp",
+        "--cfg=__unicase__defauler_hasher",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.6.0",
+    # buildifier: leave-alone
+    deps = [
+        ":unicase_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-bidi-0.3.7.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-bidi-0.3.7.bazel
new file mode 100644
index 0000000..b3221a5
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-bidi-0.3.7.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "unicode_bidi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.7",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-normalization-0.1.19.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-normalization-0.1.19.bazel
new file mode 100644
index 0000000..b3858b8
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-normalization-0.1.19.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "bench" with type "bench" omitted
+
+rust_library(
+    name = "unicode_normalization",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.19",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__tinyvec__1_5_0//:tinyvec",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel
new file mode 100644
index 0000000..bdf802a
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-segmentation-1.8.0.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "graphemes" with type "bench" omitted
+
+# Unsupported target "unicode_words" with type "bench" omitted
+
+# Unsupported target "word_bounds" with type "bench" omitted
+
+rust_library(
+    name = "unicode_segmentation",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "1.8.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel
new file mode 100644
index 0000000..4e29489
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.unicode-xid-0.2.2.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "xid" with type "bench" omitted
+
+rust_library(
+    name = "unicode_xid",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.2",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
+
+# Unsupported target "exhaustive_tests" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.url-2.2.2.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.url-2.2.2.bazel
new file mode 100644
index 0000000..965da58
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.url-2.2.2.bazel
@@ -0,0 +1,63 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "parse_url" with type "bench" omitted
+
+rust_library(
+    name = "url",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "2.2.2",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__form_urlencoded__1_0_1//:form_urlencoded",
+        "@rules_rust_wasm_bindgen__idna__0_2_3//:idna",
+        "@rules_rust_wasm_bindgen__matches__0_1_9//:matches",
+        "@rules_rust_wasm_bindgen__percent_encoding__2_1_0//:percent_encoding",
+    ],
+)
+
+# Unsupported target "data" with type "test" omitted
+
+# Unsupported target "unit" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.vcpkg-0.2.15.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.vcpkg-0.2.15.bazel
new file mode 100644
index 0000000..d58cb85
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.vcpkg-0.2.15.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "vcpkg",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.15",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.version_check-0.9.3.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.version_check-0.9.3.bazel
new file mode 100644
index 0000000..f2848d8
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.version_check-0.9.3.bazel
@@ -0,0 +1,53 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "version_check",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.9.3",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wait-timeout-0.2.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wait-timeout-0.2.0.bazel
new file mode 100644
index 0000000..5c86484
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wait-timeout-0.2.0.bazel
@@ -0,0 +1,227 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_exit",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/bin/exit.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        ":wait_timeout",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_reader",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/bin/reader.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        ":wait_timeout",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_sleep",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/bin/sleep.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        ":wait_timeout",
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+rust_library(
+    name = "wait_timeout",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(unix)
+        (
+            "@rules_rust//rust/platform:i686-apple-darwin",
+            "@rules_rust//rust/platform:i686-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-darwin",
+            "@rules_rust//rust/platform:x86_64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:aarch64-apple-darwin",
+            "@rules_rust//rust/platform:aarch64-apple-ios",
+            "@rules_rust//rust/platform:aarch64-linux-android",
+            "@rules_rust//rust/platform:aarch64-unknown-linux-gnu",
+            "@rules_rust//rust/platform:arm-unknown-linux-gnueabi",
+            "@rules_rust//rust/platform:i686-linux-android",
+            "@rules_rust//rust/platform:i686-unknown-freebsd",
+            "@rules_rust//rust/platform:powerpc-unknown-linux-gnu",
+            "@rules_rust//rust/platform:s390x-unknown-linux-gnu",
+            "@rules_rust//rust/platform:x86_64-apple-ios",
+            "@rules_rust//rust/platform:x86_64-linux-android",
+            "@rules_rust//rust/platform:x86_64-unknown-freebsd",
+        ): [
+            "@rules_rust_wasm_bindgen__libc__0_2_107//:libc",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+# Unsupported target "smoke" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-0.19.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-0.19.0.bazel
new file mode 100644
index 0000000..2c656e4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-0.19.0.bazel
@@ -0,0 +1,72 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benches" with type "bench" omitted
+
+# Unsupported target "build-wasm-from-scratch" with type "example" omitted
+
+# Unsupported target "parse" with type "example" omitted
+
+# Unsupported target "round-trip" with type "example" omitted
+
+rust_library(
+    name = "walrus",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "parallel",
+        "rayon",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__walrus_macro__0_19_0//:walrus_macro",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.19.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__id_arena__2_2_1//:id_arena",
+        "@rules_rust_wasm_bindgen__leb128__0_2_5//:leb128",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__rayon__1_5_1//:rayon",
+        "@rules_rust_wasm_bindgen__wasmparser__0_77_0//:wasmparser",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-macro-0.19.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-macro-0.19.0.bazel
new file mode 100644
index 0000000..c85ede7
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.walrus-macro-0.19.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_proc_macro(
+    name = "walrus_macro",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.19.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__heck__0_3_3//:heck",
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__syn__1_0_81//:syn",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
new file mode 100644
index 0000000..88a85d4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasi-0.10.2+wasi-snapshot-preview1.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0 OR (Apache-2.0 OR MIT)"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.10.2+wasi-snapshot-preview1",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-0.2.78.bazel
new file mode 100644
index 0000000..b3d6168
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-0.2.78.bazel
@@ -0,0 +1,105 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "wasm_bindgen_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "default",
+        "spans",
+        "std",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "wasm_bindgen",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "spans",
+        "std",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__wasm_bindgen_macro__0_2_78//:wasm_bindgen_macro",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        ":wasm_bindgen_build_script",
+        "@rules_rust_wasm_bindgen__cfg_if__1_0_0//:cfg_if",
+    ],
+)
+
+# Unsupported target "headless" with type "test" omitted
+
+# Unsupported target "must_use" with type "test" omitted
+
+# Unsupported target "non_wasm" with type "test" omitted
+
+# Unsupported target "std-crate-no-std-dep" with type "test" omitted
+
+# Unsupported target "unwrap_throw" with type "test" omitted
+
+# Unsupported target "wasm" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-backend-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-backend-0.2.78.bazel
new file mode 100644
index 0000000..2eab676
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-backend-0.2.78.bazel
@@ -0,0 +1,61 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_backend",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "spans",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__bumpalo__3_8_0//:bumpalo",
+        "@rules_rust_wasm_bindgen__lazy_static__1_4_0//:lazy_static",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__syn__1_0_81//:syn",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-0.2.78.bazel
new file mode 100644
index 0000000..da9e03e
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-0.2.78.bazel
@@ -0,0 +1,149 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_wasm_bindgen",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/wasm-bindgen.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__curl__0_4_40//:curl",
+        "@rules_rust_wasm_bindgen__docopt__1_1_1//:docopt",
+        "@rules_rust_wasm_bindgen__env_logger__0_8_4//:env_logger",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__rouille__3_4_0//:rouille",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_cli_support__0_2_78//:wasm_bindgen_cli_support",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    ],
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_wasm_bindgen_test_runner",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/wasm-bindgen-test-runner/main.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__curl__0_4_40//:curl",
+        "@rules_rust_wasm_bindgen__docopt__1_1_1//:docopt",
+        "@rules_rust_wasm_bindgen__env_logger__0_8_4//:env_logger",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__rouille__3_4_0//:rouille",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_cli_support__0_2_78//:wasm_bindgen_cli_support",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    ],
+)
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_wasm2es6js",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/bin/wasm2es6js.rs",
+    data = [],
+    edition = "2018",
+    proc_macro_deps = [
+        "@rules_rust_wasm_bindgen__serde_derive__1_0_130//:serde_derive",
+    ],
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__curl__0_4_40//:curl",
+        "@rules_rust_wasm_bindgen__docopt__1_1_1//:docopt",
+        "@rules_rust_wasm_bindgen__env_logger__0_8_4//:env_logger",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__rouille__3_4_0//:rouille",
+        "@rules_rust_wasm_bindgen__serde__1_0_130//:serde",
+        "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_cli_support__0_2_78//:wasm_bindgen_cli_support",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    ],
+)
+
+# Unsupported target "interface-types" with type "test" omitted
+
+# Unsupported target "reference" with type "test" omitted
+
+# Unsupported target "wasm-bindgen" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-support-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-support-0.2.78.bazel
new file mode 100644
index 0000000..383b043
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-cli-support-0.2.78.bazel
@@ -0,0 +1,69 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_cli_support",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__base64__0_9_3//:base64",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__rustc_demangle__0_1_21//:rustc_demangle",
+        "@rules_rust_wasm_bindgen__serde_json__1_0_69//:serde_json",
+        "@rules_rust_wasm_bindgen__tempfile__3_2_0//:tempfile",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_externref_xform__0_2_78//:wasm_bindgen_externref_xform",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_multi_value_xform__0_2_78//:wasm_bindgen_multi_value_xform",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_threads_xform__0_2_78//:wasm_bindgen_threads_xform",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_wasm_conventions__0_2_78//:wasm_bindgen_wasm_conventions",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_wasm_interpreter__0_2_78//:wasm_bindgen_wasm_interpreter",
+        "@rules_rust_wasm_bindgen__wit_text__0_8_0//:wit_text",
+        "@rules_rust_wasm_bindgen__wit_validator__0_2_1//:wit_validator",
+        "@rules_rust_wasm_bindgen__wit_walrus__0_6_0//:wit_walrus",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-externref-xform-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-externref-xform-0.2.78.bazel
new file mode 100644
index 0000000..fd43bb2
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-externref-xform-0.2.78.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_externref_xform",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+    ],
+)
+
+# Unsupported target "all" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-0.2.78.bazel
new file mode 100644
index 0000000..eef1fa1
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-0.2.78.bazel
@@ -0,0 +1,58 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_proc_macro(
+    name = "wasm_bindgen_macro",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "spans",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_macro_support__0_2_78//:wasm_bindgen_macro_support",
+    ],
+)
+
+# Unsupported target "ui" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-support-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-support-0.2.78.bazel
new file mode 100644
index 0000000..4676a13
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-macro-support-0.2.78.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_macro_support",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "spans",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__proc_macro2__1_0_32//:proc_macro2",
+        "@rules_rust_wasm_bindgen__quote__1_0_10//:quote",
+        "@rules_rust_wasm_bindgen__syn__1_0_81//:syn",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_backend__0_2_78//:wasm_bindgen_backend",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_shared__0_2_78//:wasm_bindgen_shared",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-multi-value-xform-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-multi-value-xform-0.2.78.bazel
new file mode 100644
index 0000000..194a8b0
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-multi-value-xform-0.2.78.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_multi_value_xform",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+    ],
+)
+
+# Unsupported target "all" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-shared-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-shared-0.2.78.bazel
new file mode 100644
index 0000000..9a73b97
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-shared-0.2.78.bazel
@@ -0,0 +1,84 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "wasm_bindgen_shared_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2018",
+    links = "wasm_bindgen",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "wasm_bindgen_shared",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        ":wasm_bindgen_shared_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-threads-xform-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-threads-xform-0.2.78.bazel
new file mode 100644
index 0000000..6e22501
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-threads-xform-0.2.78.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_threads_xform",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_wasm_conventions__0_2_78//:wasm_bindgen_wasm_conventions",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-conventions-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-conventions-0.2.78.bazel
new file mode 100644
index 0000000..c847aaa
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-conventions-0.2.78.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_wasm_conventions",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-interpreter-0.2.78.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-interpreter-0.2.78.bazel
new file mode 100644
index 0000000..216f2c9
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasm-bindgen-wasm-interpreter-0.2.78.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasm_bindgen_wasm_interpreter",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.78",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__log__0_4_14//:log",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wasm_bindgen_wasm_conventions__0_2_78//:wasm_bindgen_wasm_conventions",
+    ],
+)
+
+# Unsupported target "smoke" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.59.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.59.0.bazel
new file mode 100644
index 0000000..b67db40
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.59.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmark" with type "bench" omitted
+
+# Unsupported target "simple" with type "example" omitted
+
+rust_library(
+    name = "wasmparser",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.59.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.77.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.77.0.bazel
new file mode 100644
index 0000000..c90a80d
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.77.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmark" with type "bench" omitted
+
+# Unsupported target "simple" with type "example" omitted
+
+rust_library(
+    name = "wasmparser",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.77.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.81.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.81.0.bazel
new file mode 100644
index 0000000..ec6874c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmparser-0.81.0.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "benchmark" with type "bench" omitted
+
+# Unsupported target "simple" with type "example" omitted
+
+rust_library(
+    name = "wasmparser",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.81.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmprinter-0.2.31.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmprinter-0.2.31.bazel
new file mode 100644
index 0000000..d160327
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wasmprinter-0.2.31.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wasmprinter",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.31",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__wasmparser__0_81_0//:wasmparser",
+    ],
+)
+
+# Unsupported target "all" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wast-21.0.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wast-21.0.0.bazel
new file mode 100644
index 0000000..dafc212
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wast-21.0.0.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wast",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "default",
+        "wasm-module",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "21.0.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__leb128__0_2_5//:leb128",
+    ],
+)
+
+# Unsupported target "annotations" with type "test" omitted
+
+# Unsupported target "comments" with type "test" omitted
+
+# Unsupported target "parse-fail" with type "test" omitted
+
+# Unsupported target "recursive" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-0.3.9.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-0.3.9.bazel
new file mode 100644
index 0000000..b741a2c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-0.3.9.bazel
@@ -0,0 +1,133 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "handleapi",
+        "libloaderapi",
+        "lmcons",
+        "minschannel",
+        "minwinbase",
+        "minwindef",
+        "processenv",
+        "schannel",
+        "securitybaseapi",
+        "sspi",
+        "std",
+        "sysinfoapi",
+        "timezoneapi",
+        "winbase",
+        "wincon",
+        "wincrypt",
+        "winerror",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+        "consoleapi",
+        "errhandlingapi",
+        "fileapi",
+        "handleapi",
+        "libloaderapi",
+        "lmcons",
+        "minschannel",
+        "minwinbase",
+        "minwindef",
+        "processenv",
+        "schannel",
+        "securitybaseapi",
+        "sspi",
+        "std",
+        "sysinfoapi",
+        "timezoneapi",
+        "winbase",
+        "wincon",
+        "wincrypt",
+        "winerror",
+        "winnt",
+        "winsock2",
+        "ws2def",
+        "ws2ipdef",
+        "ws2tcpip",
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.3.9",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..2bd58be
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_i686_pc_windows_gnu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi_i686_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_i686_pc_windows_gnu_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel
new file mode 100644
index 0000000..9cf3e74
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-util-0.1.5.bazel
@@ -0,0 +1,64 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "unencumbered",  # Unlicense from expression "Unlicense OR MIT"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "winapi_util",
+    srcs = glob(["**/*.rs"]),
+    aliases = {
+    },
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.5",
+    # buildifier: leave-alone
+    deps = [
+    ] + selects.with_or({
+        # cfg(windows)
+        (
+            "@rules_rust//rust/platform:i686-pc-windows-msvc",
+            "@rules_rust//rust/platform:x86_64-pc-windows-msvc",
+        ): [
+            "@rules_rust_wasm_bindgen__winapi__0_3_9//:winapi",
+        ],
+        "//conditions:default": [],
+    }),
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
new file mode 100644
index 0000000..41d0496
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel
@@ -0,0 +1,83 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # MIT from expression "MIT OR Apache-2.0"
+])
+
+# Generated Targets
+# buildifier: disable=out-of-order-load
+# buildifier: disable=load-on-top
+load(
+    "@rules_rust//cargo:cargo_build_script.bzl",
+    "cargo_build_script",
+)
+
+cargo_build_script(
+    name = "winapi_x86_64_pc_windows_gnu_build_script",
+    srcs = glob(["**/*.rs"]),
+    build_script_env = {
+    },
+    crate_features = [
+    ],
+    crate_root = "build.rs",
+    data = glob(["**"]),
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    visibility = ["//visibility:private"],
+    deps = [
+    ],
+)
+
+rust_library(
+    name = "winapi_x86_64_pc_windows_gnu",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2015",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.4.0",
+    # buildifier: leave-alone
+    deps = [
+        ":winapi_x86_64_pc_windows_gnu_build_script",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-parser-0.2.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-parser-0.2.0.bazel
new file mode 100644
index 0000000..d571710
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-parser-0.2.0.bazel
@@ -0,0 +1,56 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wit_parser",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__leb128__0_2_5//:leb128",
+        "@rules_rust_wasm_bindgen__wit_schema_version__0_1_0//:wit_schema_version",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-printer-0.2.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-printer-0.2.0.bazel
new file mode 100644
index 0000000..51f92a1
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-printer-0.2.0.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "wasm2wat" with type "example" omitted
+
+rust_library(
+    name = "wit_printer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__wasmprinter__0_2_31//:wasmprinter",
+        "@rules_rust_wasm_bindgen__wit_parser__0_2_0//:wit_parser",
+        "@rules_rust_wasm_bindgen__wit_schema_version__0_1_0//:wit_schema_version",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-schema-version-0.1.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-schema-version-0.1.0.bazel
new file mode 100644
index 0000000..cda38e4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-schema-version-0.1.0.bazel
@@ -0,0 +1,77 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_binary(
+    # Prefix bin name to disambiguate from (probable) collision with lib name
+    # N.B.: The exact form of this is subject to change.
+    name = "cargo_bin_wit_schema_version",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/main.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.0",
+    # buildifier: leave-alone
+    deps = [
+        ":wit_schema_version",
+    ],
+)
+
+rust_library(
+    name = "wit_schema_version",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.1.0",
+    # buildifier: leave-alone
+    deps = [
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-text-0.8.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-text-0.8.0.bazel
new file mode 100644
index 0000000..29c068f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-text-0.8.0.bazel
@@ -0,0 +1,60 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+# Unsupported target "wat2wasm" with type "example" omitted
+
+rust_library(
+    name = "wit_text",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.8.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__wast__21_0_0//:wast",
+        "@rules_rust_wasm_bindgen__wit_writer__0_2_0//:wit_writer",
+    ],
+)
+
+# Unsupported target "all" with type "test" omitted
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-validator-0.2.1.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-validator-0.2.1.bazel
new file mode 100644
index 0000000..4e3f09c
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-validator-0.2.1.bazel
@@ -0,0 +1,57 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wit_validator",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.1",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__wasmparser__0_59_0//:wasmparser",
+        "@rules_rust_wasm_bindgen__wit_parser__0_2_0//:wit_parser",
+        "@rules_rust_wasm_bindgen__wit_schema_version__0_1_0//:wit_schema_version",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-walrus-0.6.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-walrus-0.6.0.bazel
new file mode 100644
index 0000000..802ae7f
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-walrus-0.6.0.bazel
@@ -0,0 +1,59 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wit_walrus",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.6.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__anyhow__1_0_45//:anyhow",
+        "@rules_rust_wasm_bindgen__id_arena__2_2_1//:id_arena",
+        "@rules_rust_wasm_bindgen__walrus__0_19_0//:walrus",
+        "@rules_rust_wasm_bindgen__wit_parser__0_2_0//:wit_parser",
+        "@rules_rust_wasm_bindgen__wit_schema_version__0_1_0//:wit_schema_version",
+        "@rules_rust_wasm_bindgen__wit_writer__0_2_0//:wit_writer",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-writer-0.2.0.bazel b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-writer-0.2.0.bazel
new file mode 100644
index 0000000..e1357c4
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/raze/remote/BUILD.wit-writer-0.2.0.bazel
@@ -0,0 +1,55 @@
+"""
+@generated
+cargo-raze crate build file.
+
+DO NOT EDIT! Replaced on runs of cargo-raze
+"""
+
+# buildifier: disable=load
+load("@bazel_skylib//lib:selects.bzl", "selects")
+
+# buildifier: disable=load
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_binary",
+    "rust_library",
+    "rust_proc_macro",
+    "rust_test",
+)
+
+package(default_visibility = [
+    # Public for visibility by "@raze__crate__version//" targets.
+    #
+    # Prefer access through "//wasm_bindgen/raze", which limits external
+    # visibility to explicit Cargo.toml dependencies.
+    "//visibility:public",
+])
+
+licenses([
+    "notice",  # Apache-2.0 from expression "Apache-2.0"
+])
+
+# Generated Targets
+
+rust_library(
+    name = "wit_writer",
+    srcs = glob(["**/*.rs"]),
+    crate_features = [
+    ],
+    crate_root = "src/lib.rs",
+    data = [],
+    edition = "2018",
+    rustc_flags = [
+        "--cap-lints=allow",
+    ],
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+    version = "0.2.0",
+    # buildifier: leave-alone
+    deps = [
+        "@rules_rust_wasm_bindgen__leb128__0_2_5//:leb128",
+        "@rules_rust_wasm_bindgen__wit_schema_version__0_1_0//:wit_schema_version",
+    ],
+)
diff --git a/third_party/rules_rust/wasm_bindgen/repositories.bzl b/third_party/rules_rust/wasm_bindgen/repositories.bzl
new file mode 100644
index 0000000..05fca81
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/repositories.bzl
@@ -0,0 +1,40 @@
+# Copyright 2019 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//wasm_bindgen/raze:crates.bzl", "rules_rust_wasm_bindgen_fetch_remote_crates")
+
+# buildifier: disable=unnamed-macro
+def rust_wasm_bindgen_repositories(register_default_toolchain = True):
+    """Declare dependencies needed for [rust_wasm_bindgen](#rust_wasm_bindgen).
+
+    Args:
+        register_default_toolchain (bool, optional): If True, the default [rust_wasm_bindgen_toolchain](#rust_wasm_bindgen_toolchain)
+            (`@rules_rust//wasm_bindgen:default_wasm_bindgen_toolchain`) is registered. This toolchain requires a set of dependencies
+            that were generated using [cargo raze](https://github.com/google/cargo-raze). These will also be loaded.
+    """
+
+    maybe(
+        http_archive,
+        name = "build_bazel_rules_nodejs",
+        sha256 = "ddb78717b802f8dd5d4c01c340ecdc007c8ced5c1df7db421d0df3d642ea0580",
+        urls = ["https://github.com/bazelbuild/rules_nodejs/releases/download/4.6.0/rules_nodejs-4.6.0.tar.gz"],
+    )
+
+    # Load dependencies of the default toolchain and register it.
+    if register_default_toolchain:
+        rules_rust_wasm_bindgen_fetch_remote_crates()
+        native.register_toolchains(str(Label("//wasm_bindgen:default_wasm_bindgen_toolchain")))
diff --git a/third_party/rules_rust/wasm_bindgen/wasm_bindgen.bzl b/third_party/rules_rust/wasm_bindgen/wasm_bindgen.bzl
new file mode 100644
index 0000000..d3a5524
--- /dev/null
+++ b/third_party/rules_rust/wasm_bindgen/wasm_bindgen.bzl
@@ -0,0 +1,202 @@
+# Copyright 2019 The Bazel Authors. All rights reserved.
+#
+# 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.
+
+# buildifier: disable=module-docstring
+load("//rust:defs.bzl", "rust_common")
+
+# buildifier: disable=bzl-visibility
+load("//rust/private:transitions.bzl", "wasm_bindgen_transition")
+load(
+    "//wasm_bindgen:providers.bzl",
+    "DeclarationInfo",
+    "JSEcmaScriptModuleInfo",
+    "JSModuleInfo",
+    "JSNamedModuleInfo",
+)
+
+_WASM_BINDGEN_DOC = """\
+Generates javascript and typescript bindings for a webassembly module using [wasm-bindgen][ws].
+
+[ws]: https://rustwasm.github.io/docs/wasm-bindgen/
+
+To use the Rust WebAssembly bindgen rules, add the following to your `WORKSPACE` file to add the
+external repositories for the Rust bindgen toolchain (in addition to the Rust rules setup):
+
+```python
+load("@rules_rust//wasm_bindgen:repositories.bzl", "rust_wasm_bindgen_repositories")
+
+rust_wasm_bindgen_repositories()
+```
+
+For more details on `rust_wasm_bindgen_repositories`, see [here](#rust_wasm_bindgen_repositories).
+
+An example of this rule in use can be seen at [@rules_rust//examples/wasm](../examples/wasm)
+"""
+
+_WASM_BINDGEN_TOOLCHAIN_DOC = """\
+The tools required for the `rust_wasm_bindgen` rule.
+
+In cases where users want to control or change the version of `wasm-bindgen` used by [rust_wasm_bindgen](#rust_wasm_bindgen),
+a unique toolchain can be created as in the example below:
+
+```python
+load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_toolchain")
+
+rust_bindgen_toolchain(
+    bindgen = "//my/cargo_raze:cargo_bin_wasm_bindgen",
+)
+
+toolchain(
+    name = "wasm_bindgen_toolchain",
+    toolchain = "wasm_bindgen_toolchain_impl",
+    toolchain_type = "@rules_rust//wasm_bindgen:wasm_bindgen_toolchain",
+)
+```
+
+Now that you have your own toolchain, you need to register it by
+inserting the following statement in your `WORKSPACE` file:
+
+```python
+register_toolchains("//my/toolchains:wasm_bindgen_toolchain")
+```
+
+For additional information, see the [Bazel toolchains documentation][toolchains].
+
+[toolchains]: https://docs.bazel.build/versions/master/toolchains.html
+"""
+
+def _rust_wasm_bindgen_impl(ctx):
+    toolchain = ctx.toolchains[Label("//wasm_bindgen:wasm_bindgen_toolchain")]
+    bindgen_bin = toolchain.bindgen
+
+    # Since the `wasm_file` attribute is behind a transition, it will be converted
+    # to a list.
+    if len(ctx.attr.wasm_file) == 1 and rust_common.crate_info in ctx.attr.wasm_file[0]:
+        target = ctx.attr.wasm_file[0]
+        crate_info = target[rust_common.crate_info]
+
+        # Provide a helpful warning informing users how to use the rule
+        if rust_common.crate_info in target:
+            supported_types = ["cdylib", "bin"]
+            if crate_info.type not in supported_types:
+                fail("The target '{}' is not a supported type: {}".format(
+                    ctx.attr.crate.label,
+                    supported_types,
+                ))
+
+        progress_message_label = target.label
+        input_file = crate_info.output
+    else:
+        progress_message_label = ctx.file.wasm_file.path
+        input_file = ctx.file.wasm_file
+
+    bindgen_wasm_module = ctx.actions.declare_file(ctx.attr.name + "_bg.wasm")
+
+    js_out = [ctx.actions.declare_file(ctx.attr.name + ".js")]
+    ts_out = [ctx.actions.declare_file(ctx.attr.name + ".d.ts")]
+
+    if ctx.attr.target == "bundler":
+        js_out.append(ctx.actions.declare_file(ctx.attr.name + "_bg.js"))
+        ts_out.append(ctx.actions.declare_file(ctx.attr.name + "_bg.wasm.d.ts"))
+
+    outputs = [bindgen_wasm_module] + js_out + ts_out
+
+    args = ctx.actions.args()
+    args.add("--target", ctx.attr.target)
+    args.add("--out-dir", bindgen_wasm_module.dirname)
+    args.add("--out-name", ctx.attr.name)
+    args.add_all(ctx.attr.bindgen_flags)
+    args.add(input_file)
+
+    ctx.actions.run(
+        executable = bindgen_bin,
+        inputs = [input_file],
+        outputs = outputs,
+        mnemonic = "RustWasmBindgen",
+        progress_message = "Generating WebAssembly bindings for {}...".format(progress_message_label),
+        arguments = [args],
+    )
+
+    # Return a structure that is compatible with the deps[] of a ts_library.
+    declarations = depset(ts_out)
+    es5_sources = depset(js_out)
+    es6_sources = depset(js_out)
+
+    return [
+        DefaultInfo(
+            files = depset(outputs),
+        ),
+        DeclarationInfo(
+            declarations = declarations,
+            transitive_declarations = declarations,
+            type_blocklisted_declarations = depset([]),
+        ),
+        JSModuleInfo(
+            direct_sources = es5_sources,
+            sources = es5_sources,
+        ),
+        JSNamedModuleInfo(
+            direct_sources = es5_sources,
+            sources = es5_sources,
+        ),
+        JSEcmaScriptModuleInfo(
+            direct_sources = es6_sources,
+            sources = es6_sources,
+        ),
+    ]
+
+rust_wasm_bindgen = rule(
+    implementation = _rust_wasm_bindgen_impl,
+    doc = _WASM_BINDGEN_DOC,
+    attrs = {
+        "bindgen_flags": attr.string_list(
+            doc = "Flags to pass directly to the bindgen executable. See https://github.com/rustwasm/wasm-bindgen/ for details.",
+        ),
+        "target": attr.string(
+            doc = "The type of output to generate. See https://rustwasm.github.io/wasm-bindgen/reference/deployment.html for details.",
+            default = "bundler",
+            values = ["web", "bundler", "nodejs", "no-modules", "deno"],
+        ),
+        "wasm_file": attr.label(
+            doc = "The `.wasm` file or crate to generate bindings for.",
+            allow_single_file = True,
+            cfg = wasm_bindgen_transition,
+            mandatory = True,
+        ),
+        "_allowlist_function_transition": attr.label(
+            default = Label("//tools/allowlists/function_transition_allowlist"),
+        ),
+    },
+    toolchains = [
+        str(Label("//wasm_bindgen:wasm_bindgen_toolchain")),
+    ],
+    incompatible_use_toolchain_transition = True,
+)
+
+def _rust_wasm_bindgen_toolchain_impl(ctx):
+    return platform_common.ToolchainInfo(
+        bindgen = ctx.executable.bindgen,
+    )
+
+rust_wasm_bindgen_toolchain = rule(
+    implementation = _rust_wasm_bindgen_toolchain_impl,
+    doc = _WASM_BINDGEN_TOOLCHAIN_DOC,
+    attrs = {
+        "bindgen": attr.label(
+            doc = "The label of a `wasm-bindgen-cli` executable.",
+            executable = True,
+            cfg = "exec",
+        ),
+    },
+)
diff --git a/third_party/rules_rust/workspace.bzl b/third_party/rules_rust/workspace.bzl
new file mode 100644
index 0000000..d30cf8e
--- /dev/null
+++ b/third_party/rules_rust/workspace.bzl
@@ -0,0 +1,7 @@
+# buildifier: disable=module-docstring
+def rust_workspace():
+    """An empty stub for compatibility with previous rules_rust releases."""
+
+    # buildifier: disable=print
+    print("The `rust_workspace()` macro is obsolete. Please remove references to it from your WORKSPACE.")
+    pass
diff --git a/tools/build_rules/js.bzl b/tools/build_rules/js.bzl
index eeb5594..f5a7543 100644
--- a/tools/build_rules/js.bzl
+++ b/tools/build_rules/js.bzl
@@ -63,25 +63,6 @@
     },
 )
 
-# Some rules (e.g. babel()) do not expose their files as runfiles. So we need
-# to do this step manually.
-def _turn_files_into_runfiles_impl(ctx):
-    files = ctx.attr.files.files
-    return [DefaultInfo(
-        files = files,
-        runfiles = ctx.runfiles(transitive_files = files),
-    )]
-
-turn_files_into_runfiles = rule(
-    implementation = _turn_files_into_runfiles_impl,
-    attrs = {
-        "files": attr.label(
-            mandatory = True,
-            doc = "The target whose files should be turned into runfiles.",
-        ),
-    },
-)
-
 def protractor_ts_test(name, srcs, deps = None, **kwargs):
     """Wraps upstream protractor_web_test_suite() to reduce boilerplate.
 
diff --git a/tools/python/runtime_binary.sh b/tools/python/runtime_binary.sh
index 0bc832c..a36f085 100755
--- a/tools/python/runtime_binary.sh
+++ b/tools/python/runtime_binary.sh
@@ -34,7 +34,7 @@
   exit 1
 fi
 
-export LD_LIBRARY_PATH="${BASE_PATH}/usr/lib/lapack:${BASE_PATH}/usr/lib/libblas:${BASE_PATH}/usr/lib/x86_64-linux-gnu:${BASE_PATH}/../matplotlib_repo/rpathed3/usr/lib"
+export LD_LIBRARY_PATH="${BASE_PATH}/usr/lib/lapack:${BASE_PATH}/usr/lib/libblas:${BASE_PATH}/usr/lib/x86_64-linux-gnu:${BASE_PATH}/../matplotlib_repo/rpathed3/usr/lib:${BASE_PATH}/usr/lib/x86_64-linux-gnu/lapack:${BASE_PATH}/usr/lib/x86_64-linux-gnu/blas"
 
 # Prevent Python from importing the host's installed packages.
 exec "$BASE_PATH"/usr/bin/python3 -sS "$@"
diff --git a/tools/rust/BUILD b/tools/rust/BUILD
index a652530..e58bb19 100644
--- a/tools/rust/BUILD
+++ b/tools/rust/BUILD
@@ -1,8 +1,55 @@
 load("@rules_rust//rust:toolchain.bzl", "rust_stdlib_filegroup", "rust_toolchain")
 load("@bazel_skylib//rules:write_file.bzl", "write_file")
 
-# Similar to the one automatically generated by @rust, but with the correct
-# hardware platform configured.
+# We have to declare our toolchains individually to get the corect constraints
+# configured so we can robustly select the correct one for each of our
+# platforms.
+
+toolchain(
+    name = "rust-toolchain-x86",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    target_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    toolchain = "@rust//:toolchain_for_x86_64-unknown-linux-gnu_impl",
+    toolchain_type = "@rules_rust//rust:toolchain",
+)
+
+toolchain(
+    name = "rust-toolchain-armv7",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    target_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:armv7",
+        # Include this so we're incompatible with the roborio platform, to avoid
+        # subtle order dependencies.
+        "//tools/platforms/hardware:raspberry_pi",
+    ],
+    toolchain = "@rust//:toolchain_for_armv7-unknown-linux-gnueabihf_impl",
+    toolchain_type = "@rules_rust//rust:toolchain",
+)
+
+toolchain(
+    name = "rust-toolchain-arm64",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    target_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:arm64",
+    ],
+    toolchain = "@rust//:toolchain_for_aarch64-unknown-linux-gnu_impl",
+    toolchain_type = "@rules_rust//rust:toolchain",
+)
+
 toolchain(
     name = "rust-toolchain-roborio",
     exec_compatible_with = [
@@ -11,6 +58,7 @@
     ],
     target_compatible_with = [
         "@platforms//os:linux",
+        "@platforms//cpu:armv7",
         "//tools/platforms/hardware:roborio",
     ],
     toolchain = "@rust//:toolchain_for_arm-unknown-linux-gnueabi_impl",
diff --git a/y2020/control_loops/drivetrain/localizer_plotter.ts b/y2020/control_loops/drivetrain/localizer_plotter.ts
index 9fe80de..b2120ef 100644
--- a/y2020/control_loops/drivetrain/localizer_plotter.ts
+++ b/y2020/control_loops/drivetrain/localizer_plotter.ts
@@ -6,7 +6,7 @@
 import {Point} from 'org_frc971/aos/network/www/plotter';
 import {Table} from 'org_frc971/aos/network/www/reflection';
 import {ByteBuffer} from 'flatbuffers';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 
 const TIME = AosPlotter.TIME;
 
diff --git a/y2020/control_loops/drivetrain/localizer_test.cc b/y2020/control_loops/drivetrain/localizer_test.cc
index cc04428..f0bcd88 100644
--- a/y2020/control_loops/drivetrain/localizer_test.cc
+++ b/y2020/control_loops/drivetrain/localizer_test.cc
@@ -603,7 +603,7 @@
 // Tests that we don't blow up if we stop getting updates for an extended period
 // of time and fall behind on fetching fron the cameras.
 TEST_F(LocalizedDrivetrainTest, FetchersHandleTimeGap) {
-  set_enable_cameras(true);
+  set_enable_cameras(false);
   set_send_delay(std::chrono::seconds(0));
   event_loop_factory()->set_network_delay(std::chrono::nanoseconds(1));
   test_event_loop_
diff --git a/y2020/control_loops/superstructure/superstructure_lib_test.cc b/y2020/control_loops/superstructure/superstructure_lib_test.cc
index 1bbf42b..b13263a 100644
--- a/y2020/control_loops/superstructure/superstructure_lib_test.cc
+++ b/y2020/control_loops/superstructure/superstructure_lib_test.cc
@@ -686,8 +686,7 @@
     goal_builder.add_turret(turret_offset);
     goal_builder.add_shooter(shooter_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   RunFor(chrono::seconds(10));
   VerifyNearGoal();
@@ -733,8 +732,7 @@
     goal_builder.add_turret(turret_offset);
     goal_builder.add_shooter(shooter_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   // Give it a lot of time to get there.
@@ -775,8 +773,7 @@
     goal_builder.add_turret(turret_offset);
     goal_builder.add_shooter(shooter_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   RunFor(chrono::seconds(8));
   VerifyNearGoal();
@@ -810,8 +807,7 @@
     goal_builder.add_turret(turret_offset);
     goal_builder.add_shooter(shooter_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   superstructure_plant_.set_peak_hood_velocity(23.0);
   // 30 hz sin wave on the hood causes acceleration to be ignored.
@@ -865,8 +861,7 @@
     goal_builder.add_shooter(shooter_offset);
     goal_builder.add_shooting(true);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   // In the beginning, the finisher and accelerator should not be ready
@@ -911,8 +906,7 @@
     goal_builder.add_intake(intake_offset);
     goal_builder.add_shooter(shooter_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   // Give it a lot of time to get there.
@@ -961,8 +955,7 @@
     goal_builder.add_climber_voltage(-10.0);
     goal_builder.add_turret(turret_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   // The turret needs to move out of the way first.  This takes some time.
@@ -986,8 +979,7 @@
     goal_builder.add_climber_voltage(10.0);
     goal_builder.add_turret(turret_offset);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   RunFor(chrono::seconds(1));
 
@@ -1175,6 +1167,8 @@
                                "y2020.control_loops.superstructure.Status");
     reader_.RemapLoggedChannel("/superstructure",
                                "y2020.control_loops.superstructure.Output");
+    reader_.RemapLoggedChannel("/drivetrain",
+                               "frc971.control_loops.drivetrain.Status");
     reader_.Register();
 
     roborio_ = aos::configuration::GetNode(reader_.configuration(), "roborio");
@@ -1221,32 +1215,27 @@
   constexpr double kShotDistance = 2.5;
   const auto target = turret::OuterPortPose(aos::Alliance::kRed);
 
-  // There was no target when this log was taken so send a position within range
-  // of the interpolation table.
-  test_event_loop_->AddPhasedLoop(
-      [&](int) {
-        auto builder = drivetrain_status_sender_.MakeBuilder();
+  // There was no target when this log was taken, so send a position within
+  // range of the interpolation table.
+  {
+    auto builder = drivetrain_status_sender_.MakeBuilder();
 
-        const auto localizer_offset =
-            builder
-                .MakeBuilder<
-                    frc971::control_loops::drivetrain::LocalizerState>()
-                .Finish();
+    const auto localizer_offset =
+        builder.MakeBuilder<frc971::control_loops::drivetrain::LocalizerState>()
+            .Finish();
 
-        auto drivetrain_status_builder =
-            builder.MakeBuilder<DrivetrainStatus>();
+    auto drivetrain_status_builder = builder.MakeBuilder<DrivetrainStatus>();
 
-        // Set the robot up at kShotAngle off from the target, kShotDistance
-        // away.
-        drivetrain_status_builder.add_x(target.abs_pos().x() +
-                                        std::cos(kShotAngle) * kShotDistance);
-        drivetrain_status_builder.add_y(target.abs_pos().y() +
-                                        std::sin(kShotAngle) * kShotDistance);
-        drivetrain_status_builder.add_localizer(localizer_offset);
+    // Set the robot up at kShotAngle off from the target, kShotDistance
+    // away.
+    drivetrain_status_builder.add_x(target.abs_pos().x() +
+                                    std::cos(kShotAngle) * kShotDistance);
+    drivetrain_status_builder.add_y(target.abs_pos().y() +
+                                    std::sin(kShotAngle) * kShotDistance);
+    drivetrain_status_builder.add_localizer(localizer_offset);
 
-        builder.CheckOk(builder.Send(drivetrain_status_builder.Finish()));
-      },
-      frc971::controls::kLoopFrequency);
+    builder.CheckOk(builder.Send(drivetrain_status_builder.Finish()));
+  }
 
   reader_.event_loop_factory()->Run();
 
@@ -1289,8 +1278,7 @@
 
     goal_builder.add_turret_tracking(true);
 
-    ASSERT_EQ(builder.Send(goal_builder.Finish()),
-              aos::RawSender::Error::kOk);
+    ASSERT_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   {
@@ -1347,8 +1335,7 @@
     goal_builder.add_shooter(shooter_goal);
     goal_builder.add_hood(hood_offset);
 
-    CHECK_EQ(builder.Send(goal_builder.Finish()),
-             aos::RawSender::Error::kOk);
+    CHECK_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
 
   RunFor(chrono::seconds(10));
@@ -1415,8 +1402,7 @@
     goal_builder.add_shooter_tracking(true);
     goal_builder.add_hood_tracking(true);
 
-    CHECK_EQ(builder.Send(goal_builder.Finish()),
-             aos::RawSender::Error::kOk);
+    CHECK_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   RunFor(chrono::seconds(10));
 
@@ -1486,8 +1472,7 @@
     goal_builder.add_shooter_tracking(true);
     goal_builder.add_hood_tracking(true);
 
-    CHECK_EQ(builder.Send(goal_builder.Finish()),
-             aos::RawSender::Error::kOk);
+    CHECK_EQ(builder.Send(goal_builder.Finish()), aos::RawSender::Error::kOk);
   }
   RunFor(chrono::seconds(10));
 
diff --git a/y2020/control_loops/superstructure/turret_plotter.ts b/y2020/control_loops/superstructure/turret_plotter.ts
index 2c3fb01..5cb15c6 100644
--- a/y2020/control_loops/superstructure/turret_plotter.ts
+++ b/y2020/control_loops/superstructure/turret_plotter.ts
@@ -7,7 +7,7 @@
 import {Point} from 'org_frc971/aos/network/www/plotter';
 import {Table} from 'org_frc971/aos/network/www/reflection';
 import {ByteBuffer} from 'flatbuffers';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 
 import Connection = proxy.Connection;
 
diff --git a/y2020/vision/sift/BUILD b/y2020/vision/sift/BUILD
index c6afc98..feecb62 100644
--- a/y2020/vision/sift/BUILD
+++ b/y2020/vision/sift/BUILD
@@ -32,7 +32,7 @@
         "fast_gaussian_generator.cc",
         "get_gaussian_kernel.h",
         "@amd64_debian_sysroot//:sysroot_files",
-        "@deb_zlib1g_dev_1_2_11_dfsg_1_amd64_deb_repo//file",
+        "@deb_zlib1g_dev_1_2_11_dfsg_2_amd64_deb_repo//file",
         "@halide_k8//:build_files",
         "@llvm_toolchain//:all-components-x86_64-linux",
     ],
diff --git a/y2020/vision/sift/fast_gaussian_halide_generator.sh b/y2020/vision/sift/fast_gaussian_halide_generator.sh
index a90f218..cec9995 100755
--- a/y2020/vision/sift/fast_gaussian_halide_generator.sh
+++ b/y2020/vision/sift/fast_gaussian_halide_generator.sh
@@ -25,7 +25,7 @@
 SOURCE="$(rlocation org_frc971/y2020/vision/sift/fast_gaussian_generator.cc)"
 HALIDE="$(rlocation halide_k8)"
 SYSROOT="$(rlocation amd64_debian_sysroot)"
-ZLIB1G_DEV_AMD64_DEB="$(rlocation deb_zlib1g_dev_1_2_11_dfsg_1_amd64_deb_repo/file/zlib1g-dev_1.2.11.dfsg-1_amd64.deb)"
+ZLIB1G_DEV_AMD64_DEB="$(rlocation deb_zlib1g_dev_1_2_11_dfsg_2_amd64_deb_repo/file/zlib1g-dev_1.2.11.dfsg-2_amd64.deb)"
 
 ZLIB1G_DEV="$(mktemp -d)"
 
diff --git a/y2020/y2020_pi_template.json b/y2020/y2020_pi_template.json
index 5ad87eb..0f8d268 100644
--- a/y2020/y2020_pi_template.json
+++ b/y2020/y2020_pi_template.json
@@ -120,7 +120,7 @@
       "name": "/pi{{ NUM }}/camera/detailed",
       "type": "frc971.vision.sift.ImageMatchResult",
       "source_node": "pi{{ NUM }}",
-      "frequency": 25,
+      "frequency": 30,
       "max_size": 1000000
     },
     {
diff --git a/y2022/BUILD b/y2022/BUILD
index 83438ec..5d29f04 100644
--- a/y2022/BUILD
+++ b/y2022/BUILD
@@ -7,9 +7,11 @@
     binaries = [
         ":setpoint_setter",
         "//aos/network:web_proxy_main",
+        "//aos/events/logging:log_cat",
     ],
     data = [
         ":aos_config",
+        ":message_bridge_client.sh",
         "@ctre_phoenix_api_cpp_athena//:shared_libraries",
         "@ctre_phoenix_cci_athena//:shared_libraries",
     ],
@@ -40,12 +42,16 @@
         "//y2022/localizer:imu_main",
         "//y2022/localizer:localizer_main",
         "//y2022/vision:image_decimator",
+        "//y2022/image_streamer:image_streamer",
+        "//aos/events/logging:log_cat",
     ],
     data = [
         ":aos_config",
+        "//y2022/image_streamer:image_streamer_start",
     ],
     dirs = [
         "//y2022/www:www_files",
+        "//y2022/image_streamer/www:www_files",
     ],
     start_binaries = [
         "//aos/events/logging:logger_main",
@@ -53,6 +59,7 @@
         "//aos/network:message_bridge_server",
         "//aos/network:web_proxy_main",
         "//y2022/vision:camera_reader",
+        "//y2022/vision:ball_color_detector",
     ],
     target_compatible_with = ["//tools/platforms/hardware:raspberry_pi"],
     target_type = "pi",
@@ -95,6 +102,7 @@
             "//y2022/localizer:localizer_output_fbs",
             "//y2022/vision:calibration_fbs",
             "//y2022/vision:target_estimate_fbs",
+            "//y2022/vision:ball_color_fbs",
         ],
         target_compatible_with = ["@platforms//os:linux"],
         visibility = ["//visibility:public"],
@@ -142,6 +150,7 @@
         "//aos/network:remote_message_fbs",
         "//frc971/vision:vision_fbs",
         "//y2022/vision:calibration_fbs",
+        "//y2022/vision:ball_color_fbs",
     ],
     target_compatible_with = ["@platforms//os:linux"],
     visibility = ["//visibility:public"],
@@ -161,6 +170,7 @@
         "//aos/network:message_bridge_client_fbs",
         "//aos/network:message_bridge_server_fbs",
         "//aos/network:timestamp_fbs",
+        "//y2022/vision:ball_color_fbs",
         "//y2019/control_loops/drivetrain:target_selector_fbs",
         "//y2022/control_loops/superstructure:superstructure_goal_fbs",
         "//y2022/control_loops/superstructure:superstructure_output_fbs",
diff --git a/y2022/actors/autonomous_actor.cc b/y2022/actors/autonomous_actor.cc
index ecc2a98..a8a2905 100644
--- a/y2022/actors/autonomous_actor.cc
+++ b/y2022/actors/autonomous_actor.cc
@@ -351,10 +351,7 @@
   if (requested_intake_.has_value()) {
     superstructure_builder.add_turret_intake(*requested_intake_);
   }
-  superstructure_builder.add_transfer_roller_speed_front(
-      transfer_roller_front_voltage_);
-  superstructure_builder.add_transfer_roller_speed_back(
-      transfer_roller_back_voltage_);
+  superstructure_builder.add_transfer_roller_speed(transfer_roller_voltage_);
   superstructure_builder.add_turret(turret_offset);
   superstructure_builder.add_catapult(catapult_goal_offset);
   superstructure_builder.add_fire(fire_);
@@ -371,8 +368,7 @@
   set_requested_intake(RequestedIntake::kFront);
   set_intake_front_goal(kExtendIntakeGoal);
   set_roller_front_voltage(kIntakeRollerVoltage);
-  set_transfer_roller_front_voltage(kRollerVoltage);
-  set_transfer_roller_back_voltage(-kRollerVoltage);
+  set_transfer_roller_voltage(kRollerVoltage);
   SendSuperstructureGoal();
 }
 
@@ -380,8 +376,7 @@
   set_requested_intake(std::nullopt);
   set_intake_front_goal(kRetractIntakeGoal);
   set_roller_front_voltage(0.0);
-  set_transfer_roller_front_voltage(0.0);
-  set_transfer_roller_back_voltage(0.0);
+  set_transfer_roller_voltage(0.0);
   SendSuperstructureGoal();
 }
 
@@ -389,8 +384,7 @@
   set_requested_intake(RequestedIntake::kBack);
   set_intake_back_goal(kExtendIntakeGoal);
   set_roller_back_voltage(kIntakeRollerVoltage);
-  set_transfer_roller_back_voltage(kRollerVoltage);
-  set_transfer_roller_front_voltage(-kRollerVoltage);
+  set_transfer_roller_voltage(-kRollerVoltage);
   SendSuperstructureGoal();
 }
 
@@ -398,8 +392,7 @@
   set_requested_intake(std::nullopt);
   set_intake_back_goal(kRetractIntakeGoal);
   set_roller_back_voltage(0.0);
-  set_transfer_roller_front_voltage(0.0);
-  set_transfer_roller_back_voltage(0.0);
+  set_transfer_roller_voltage(0.0);
   SendSuperstructureGoal();
 }
 
diff --git a/y2022/actors/autonomous_actor.h b/y2022/actors/autonomous_actor.h
index 0168630..ec66fb3 100644
--- a/y2022/actors/autonomous_actor.h
+++ b/y2022/actors/autonomous_actor.h
@@ -41,11 +41,8 @@
   void set_roller_back_voltage(double roller_back_voltage) {
     roller_back_voltage_ = roller_back_voltage;
   }
-  void set_transfer_roller_front_voltage(double voltage) {
-    transfer_roller_front_voltage_ = voltage;
-  }
-  void set_transfer_roller_back_voltage(double voltage) {
-    transfer_roller_back_voltage_ = voltage;
+  void set_transfer_roller_voltage(double voltage) {
+    transfer_roller_voltage_ = voltage;
   }
   void set_requested_intake(std::optional<RequestedIntake> requested_intake) {
     requested_intake_ = requested_intake;
@@ -78,8 +75,7 @@
   double intake_back_goal_ = 0.0;
   double roller_front_voltage_ = 0.0;
   double roller_back_voltage_ = 0.0;
-  double transfer_roller_front_voltage_ = 0.0;
-  double transfer_roller_back_voltage_ = 0.0;
+  double transfer_roller_voltage_ = 0.0;
   std::optional<RequestedIntake> requested_intake_ = std::nullopt;
   double turret_goal_ = 0.0;
   bool fire_ = false;
diff --git a/y2022/actors/splines/spline_5_ball_1.json b/y2022/actors/splines/spline_5_ball_1.json
index 91a31f6..da3e4cf 100644
--- a/y2022/actors/splines/spline_5_ball_1.json
+++ b/y2022/actors/splines/spline_5_ball_1.json
@@ -1 +1 @@
-{"spline_count": 1, "spline_x": [-0.18145693702491972, -0.1806686149879133, -0.05595918014581436, 5.568337297714338, 2.9263972876382542, 1.8899826868983047], "spline_y": [2.346189480782648, 3.6925675615333544, 4.41262134323365, 2.806871944572777, 2.3713873275272683, 1.4720189432649824], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 3.0}, {"constraint_type": "LATERAL_ACCELERATION", "value": 2.5}, {"constraint_type": "VOLTAGE", "value": 12.0}, {"constraint_type": "VELOCITY", "value": 0.8, "start_distance": 1.0, "end_distance": 1.15}]}
+{"spline_count": 1, "spline_x": [-0.18145693702491972, -0.1806686149879133, -0.05595918014581436, 5.762204620882601, 2.7805678460726355, 1.6146169804687496], "spline_y": [2.346189480782648, 3.6925675615333544, 4.41262134323365, 2.4753395126953124, 2.2341888067461992, 1.3005395681218328], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 3.0}, {"constraint_type": "LATERAL_ACCELERATION", "value": 2.5}, {"constraint_type": "VOLTAGE", "value": 12.0}, {"constraint_type": "VELOCITY", "value": 0.8, "start_distance": 1.0, "end_distance": 1.15}]}
\ No newline at end of file
diff --git a/y2022/actors/splines/spline_5_ball_2.json b/y2022/actors/splines/spline_5_ball_2.json
index 7d7e8c6..3efd1ee 100644
--- a/y2022/actors/splines/spline_5_ball_2.json
+++ b/y2022/actors/splines/spline_5_ball_2.json
@@ -1 +1 @@
-{"spline_count": 1, "spline_x": [1.8977893624261148, 2.493489118397258, 3.0938041880159797, 6.267891145316549, 6.049173922736376, 6.833717690390506], "spline_y": [1.4682096511768088, 2.0094316068927602, 1.5053043317512498, 2.1686488722080637, 2.082692598659578, 2.8053622716611706], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 3.0}, {"constraint_type": "LATERAL_ACCELERATION", "value": 3}, {"constraint_type": "VOLTAGE", "value": 12.0}]}
+{"spline_count": 1, "spline_x": [1.6037446032516893, 2.2055167265625, 2.8212725389450344, 6.148134261553881, 5.92062789622044, 6.7046250148859805], "spline_y": [1.2861465107685808, 1.7993420469805743, 1.286805497714088, 2.0935212995201415, 1.9849658141364017, 2.755576908889358], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 3.0}, {"constraint_type": "LATERAL_ACCELERATION", "value": 3.0}, {"constraint_type": "VOLTAGE", "value": 12.0}]}
\ No newline at end of file
diff --git a/y2022/actors/splines/spline_5_ball_3.json b/y2022/actors/splines/spline_5_ball_3.json
index 8d37834..6b239fc 100644
--- a/y2022/actors/splines/spline_5_ball_3.json
+++ b/y2022/actors/splines/spline_5_ball_3.json
@@ -1 +1 @@
-{"spline_count": 1, "spline_x": [6.8497036863806855, 6.523770855698178, 5.901632869573503, 3.625913896364584, 2.7205221377079836, 2.0513600546151287], "spline_y": [2.7941148215833196, 2.479530267377096, 2.134117802271161, 2.01574966936852, 2.0870521240271422, 1.5304761433039502], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 4}, {"constraint_type": "LATERAL_ACCELERATION", "value": 3}, {"constraint_type": "VOLTAGE", "value": 12.0}]}
+{"spline_count": 1, "spline_x": [6.702231375950168, 6.373881457031249, 5.758688966174009, 3.1788453508620487, 2.273453592205448, 1.6114305300886826], "spline_y": [2.7438724869219806, 2.4293757261929896, 2.0768880836927197, 1.7809922274871859, 1.852294682145808, 1.2821724076488596], "constraints": [{"constraint_type": "LONGITUDINAL_ACCELERATION", "value": 4.0}, {"constraint_type": "LATERAL_ACCELERATION", "value": 3}, {"constraint_type": "VOLTAGE", "value": 12.0}]}
\ No newline at end of file
diff --git a/y2022/constants.cc b/y2022/constants.cc
index acd36b4..a6b9a28 100644
--- a/y2022/constants.cc
+++ b/y2022/constants.cc
@@ -132,10 +132,47 @@
 
   // Interpolation table for comp and practice robots
   r.shot_interpolation_table = InterpolationTable<Values::ShotParams>({
-      {1, {0.03, 18.0}},
-      {10, {0.03, 18.0}},
+      {1.0, {0.0, 19.0}},
+      {1.6, {0.0, 19.0}},
+      {1.9, {0.1, 19.0}},
+      {2.12, {0.15, 18.8}},
+      {2.9, {0.25, 19.2}},
+      {3.2, {0.28, 20.5}},
+
+      {3.86, {0.35, 20.9}},
+      {4.9, {0.4, 21.9}},
+      {5.4, {0.4, 23.9}},
+      {6.0, {0.40, 25.0}},
+      {7.0, {0.37, 27.1}},
+
+      {7.8, {0.35, 28.0}},
+      {10.0, {0.35, 28.0}},
   });
 
+  if (false) {
+    // 1.5 meters -> 2.7
+    // 2.3 meters -> 4.7
+    // 4.5 meters -> 7.0
+    // 7.0 meters -> 9.0
+
+    constexpr double kShotVelocity = 9.0;
+    r.shot_velocity_interpolation_table =
+        InterpolationTable<Values::ShotVelocityParams>({
+            {1.0, {kShotVelocity}},
+            {10.0, {kShotVelocity}},
+        });
+  } else {
+    r.shot_velocity_interpolation_table =
+        InterpolationTable<Values::ShotVelocityParams>({
+            {1.0, {2.7}},
+            {1.5, {2.7}},
+            {2.3, {4.7}},
+            {4.5, {7.0}},
+            {7.0, {9.0}},
+            {10.0, {9.0}},
+        });
+  }
+
   switch (team) {
     // A set of constants for tests.
     case 1:
@@ -144,6 +181,12 @@
           {5, {0.6, 10.0}},
       });
 
+      r.shot_velocity_interpolation_table =
+          InterpolationTable<Values::ShotVelocityParams>({
+              {2, {2.0}},
+              {5, {4.0}},
+          });
+
       climber->potentiometer_offset = 0.0;
       intake_front->potentiometer_offset = 0.0;
       intake_front->subsystem_params.zeroing_constants
@@ -162,20 +205,26 @@
       break;
 
     case kCompTeamNumber:
-      climber->potentiometer_offset = -0.0463847608752;
+      climber->potentiometer_offset = -0.0463847608752 - 0.0376876182111 +
+                                      0.0629263851579 - 0.00682128836400001 +
+                                      0.0172237531191;
 
-      intake_front->potentiometer_offset = 2.79628370453323;
+      intake_front->potentiometer_offset =
+          2.79628370453323 - 0.0250288114832881 + 0.577152542437606;
       intake_front->subsystem_params.zeroing_constants
-          .measured_absolute_position = 0.248921954833972;
+          .measured_absolute_position = 0.26963366701647;
 
-      intake_back->potentiometer_offset = 3.1409576474047;
+      intake_back->potentiometer_offset =
+          3.1409576474047 + 0.278653334013286 + 0.00879137908308503;
       intake_back->subsystem_params.zeroing_constants
-          .measured_absolute_position = 0.280099007470002;
+          .measured_absolute_position = 0.242434593996789;
 
       turret->potentiometer_offset = -9.99970387166721 + 0.06415943 +
-                                     0.073290115367682 - 0.0634440443622909;
+                                     0.073290115367682 - 0.0634440443622909 +
+                                     0.213601224728352 + 0.0657973101027296 -
+                                     0.114726411377978;
       turret->subsystem_params.zeroing_constants.measured_absolute_position =
-          0.568649928102931;
+          0.39190961531060;
 
       flipper_arm_left->potentiometer_offset = -6.4;
       flipper_arm_right->potentiometer_offset = 5.56;
@@ -209,6 +258,12 @@
           {5, {0.6, 10.0}},
       });
 
+      r.shot_velocity_interpolation_table =
+          InterpolationTable<Values::ShotVelocityParams>({
+              {2, {2.0}},
+              {5, {4.0}},
+          });
+
       climber->potentiometer_offset = 0.0;
       intake_front->potentiometer_offset = 0.0;
       intake_front->subsystem_params.zeroing_constants
diff --git a/y2022/constants.h b/y2022/constants.h
index 610ddc0..4b5351e 100644
--- a/y2022/constants.h
+++ b/y2022/constants.h
@@ -45,7 +45,7 @@
   // Climber
   static constexpr ::frc971::constants::Range kClimberRange() {
     return ::frc971::constants::Range{
-        .lower_hard = -0.01, .upper_hard = 0.55, .lower = 0.005, .upper = 0.48};
+        .lower_hard = -0.01, .upper_hard = 0.59, .lower = 0.003, .upper = 0.555};
   }
   static constexpr double kClimberPotMetersPerRevolution() {
     return 22 * 0.25 * 0.0254;
@@ -114,9 +114,9 @@
   static constexpr ::frc971::constants::Range kTurretRange() {
     return ::frc971::constants::Range{
         .lower_hard = -7.0,  // Back Hard
-        .upper_hard = 3.0,   // Front Hard
+        .upper_hard = 3.4,   // Front Hard
         .lower = -6.5,       // Back Soft
-        .upper = 2.5         // Front Soft
+        .upper = 3.15        // Front Soft
     };
   }
 
@@ -218,13 +218,28 @@
     static ShotParams BlendY(double coefficient, ShotParams a1, ShotParams a2) {
       using ::frc971::shooter_interpolation::Blend;
       return ShotParams{
-          Blend(coefficient, a1.shot_angle, a2.shot_angle),
-          Blend(coefficient, a1.shot_velocity, a2.shot_velocity),
+          .shot_angle = Blend(coefficient, a1.shot_angle, a2.shot_angle),
+          .shot_velocity =
+              Blend(coefficient, a1.shot_velocity, a2.shot_velocity),
       };
     }
   };
 
+  struct ShotVelocityParams {
+    // Speed over ground to use for shooting-on-the-fly.
+    double shot_speed_over_ground;
+
+    static ShotVelocityParams BlendY(double coefficient, ShotVelocityParams a1,
+                                     ShotVelocityParams a2) {
+      using ::frc971::shooter_interpolation::Blend;
+      return ShotVelocityParams{Blend(coefficient, a1.shot_speed_over_ground,
+                                      a2.shot_speed_over_ground)};
+    }
+  };
+
   InterpolationTable<ShotParams> shot_interpolation_table;
+
+  InterpolationTable<ShotVelocityParams> shot_velocity_interpolation_table;
 };
 
 // Creates and returns a Values instance for the constants.
diff --git a/y2022/control_loops/python/catapult_lib.py b/y2022/control_loops/python/catapult_lib.py
index d6040d1..4a88b14 100644
--- a/y2022/control_loops/python/catapult_lib.py
+++ b/y2022/control_loops/python/catapult_lib.py
@@ -15,9 +15,9 @@
 class Catapult(angular_system.AngularSystem):
     def __init__(self, params, name="Catapult"):
         super(Catapult, self).__init__(params, name)
-        # Signal that we have a single cycle output delay to compensate for in
+        # Signal that we have a 2 cycle output delay to compensate for in
         # our observer.
-        self.delayed_u = True
+        self.delayed_u = 2
 
         self.InitializeState()
 
@@ -25,9 +25,9 @@
 class IntegralCatapult(angular_system.IntegralAngularSystem):
     def __init__(self, params, name="IntegralCatapult"):
         super(IntegralCatapult, self).__init__(params, name=name)
-        # Signal that we have a single cycle output delay to compensate for in
+        # Signal that we have a 2 cycle output delay to compensate for in
         # our observer.
-        self.delayed_u = True
+        self.delayed_u = 2
 
         self.InitializeState()
 
diff --git a/y2022/control_loops/python/climber.py b/y2022/control_loops/python/climber.py
index fd1707b..5f5ae38 100755
--- a/y2022/control_loops/python/climber.py
+++ b/y2022/control_loops/python/climber.py
@@ -17,7 +17,7 @@
 kClimber = linear_system.LinearSystemParams(
     name='Climber',
     motor=control_loop.Falcon(),
-    G=(1.0 / 10.0) * (1.0 / 3.0) * (1.0 / 3.0),
+    G=(1.0 / 4.0) * (1.0 / 3.0) * (1.0 / 3.0),
     radius=22 * 0.25 / numpy.pi / 2.0 * 0.0254,
     mass=2.0,
     q_pos=0.10,
diff --git a/y2022/control_loops/superstructure/BUILD b/y2022/control_loops/superstructure/BUILD
index eb713c2..ebd9ace 100644
--- a/y2022/control_loops/superstructure/BUILD
+++ b/y2022/control_loops/superstructure/BUILD
@@ -177,6 +177,7 @@
         "//frc971/control_loops:control_loops_fbs",
         "//frc971/control_loops:profiled_subsystem_fbs",
         "//frc971/control_loops/drivetrain:drivetrain_output_fbs",
+        "//frc971/queues:gyro_fbs",
         "//third_party:phoenix",
         "//third_party:wpilib",
     ],
diff --git a/y2022/control_loops/superstructure/catapult/catapult.cc b/y2022/control_loops/superstructure/catapult/catapult.cc
index 2093174..a04d8c9 100644
--- a/y2022/control_loops/superstructure/catapult/catapult.cc
+++ b/y2022/control_loops/superstructure/catapult/catapult.cc
@@ -342,7 +342,9 @@
     latched_shot_velocity = catapult_goal->shot_velocity();
   }
 
-  if (catapult_.running()) {
+  // Don't update last_firing_ if the catapult is disabled, so that we actually
+  // end up firing once it's enabled
+  if (catapult_.running() && !catapult_disabled) {
     last_firing_ = fire;
   }
 
@@ -359,10 +361,13 @@
       // hardware applies it, we need to run the optimizer for the position at
       // the *next* control loop cycle.
 
-      const Eigen::Vector3d next_X =
-          catapult_.controller().plant().A() * catapult_.estimated_state() +
-          catapult_.controller().plant().B() *
-              catapult_.controller().observer().last_U();
+      Eigen::Vector3d next_X = catapult_.estimated_state();
+      for (int i = catapult_.controller().plant().coefficients().delayed_u;
+           i > 1; --i) {
+        next_X = catapult_.controller().plant().A() * next_X +
+                 catapult_.controller().plant().B() *
+                     catapult_.controller().observer().last_U(i - 1);
+      }
 
       catapult_mpc_.SetState(
           next_X.block<2, 1>(0, 0),
diff --git a/y2022/control_loops/superstructure/catapult_plotter.ts b/y2022/control_loops/superstructure/catapult_plotter.ts
index 5736426..90db40b 100644
--- a/y2022/control_loops/superstructure/catapult_plotter.ts
+++ b/y2022/control_loops/superstructure/catapult_plotter.ts
@@ -35,7 +35,7 @@
   positionPlot.addMessageLine(status, ['catapult', 'position']).setColor(GREEN).setPointSize(4.0);
   positionPlot.addMessageLine(status, ['catapult', 'velocity']).setColor(PINK).setPointSize(1.0);
   positionPlot.addMessageLine(status, ['catapult', 'calculated_velocity']).setColor(BROWN).setPointSize(1.0);
-  positionPlot.addMessageLine(position, ['catapult', 'pot']).setColor(WHITE).setPointSize(1.0);
+  positionPlot.addMessageLine(position, ['catapult', 'pot']).setColor(WHITE).setPointSize(4.0);
   positionPlot.addMessageLine(status, ['catapult', 'estimator_state', 'position']).setColor(CYAN).setPointSize(1.0);
 
   const voltagePlot =
diff --git a/y2022/control_loops/superstructure/led_indicator.cc b/y2022/control_loops/superstructure/led_indicator.cc
index 54b0b00..94d0506 100644
--- a/y2022/control_loops/superstructure/led_indicator.cc
+++ b/y2022/control_loops/superstructure/led_indicator.cc
@@ -5,24 +5,28 @@
 namespace y2022::control_loops::superstructure {
 
 LedIndicator::LedIndicator(aos::EventLoop *event_loop)
-    : drivetrain_output_fetcher_(
-          event_loop->MakeFetcher<frc971::control_loops::drivetrain::Output>(
+    : event_loop_(event_loop),
+      drivetrain_output_fetcher_(
+          event_loop_->MakeFetcher<frc971::control_loops::drivetrain::Output>(
               "/drivetrain")),
       superstructure_status_fetcher_(
-          event_loop->MakeFetcher<Status>("/superstructure")),
+          event_loop_->MakeFetcher<Status>("/superstructure")),
       server_statistics_fetcher_(
-          event_loop->MakeFetcher<aos::message_bridge::ServerStatistics>(
+          event_loop_->MakeFetcher<aos::message_bridge::ServerStatistics>(
               "/roborio/aos")),
       client_statistics_fetcher_(
-          event_loop->MakeFetcher<aos::message_bridge::ClientStatistics>(
-              "/roborio/aos")) {
+          event_loop_->MakeFetcher<aos::message_bridge::ClientStatistics>(
+              "/roborio/aos")),
+      gyro_reading_fetcher_(
+          event_loop_->MakeFetcher<frc971::sensors::GyroReading>(
+              "/drivetrain")) {
   led::CANdleConfiguration config;
   config.statusLedOffWhenActive = true;
   config.disableWhenLOS = false;
   config.brightnessScalar = 1.0;
   candle_.ConfigAllSettings(config, 0);
 
-  event_loop->AddPhasedLoop([&](int) { DecideColor(); },
+  event_loop_->AddPhasedLoop([&](int) { DecideColor(); },
                             std::chrono::milliseconds(20));
 }
 
@@ -36,7 +40,8 @@
 bool DisconnectedPiServer(
     const aos::message_bridge::ServerStatistics &server_stats) {
   for (const auto *pi_server_status : *server_stats.connections()) {
-    if (pi_server_status->state() == aos::message_bridge::State::DISCONNECTED) {
+    if (pi_server_status->state() == aos::message_bridge::State::DISCONNECTED &&
+        pi_server_status->node()->name()->string_view() != "logger") {
       return true;
     }
   }
@@ -46,7 +51,8 @@
 bool DisconnectedPiClient(
     const aos::message_bridge::ClientStatistics &client_stats) {
   for (const auto *pi_client_status : *client_stats.connections()) {
-    if (pi_client_status->state() == aos::message_bridge::State::DISCONNECTED) {
+    if (pi_client_status->state() == aos::message_bridge::State::DISCONNECTED &&
+        pi_client_status->node()->name()->string_view() != "logger") {
       return true;
     }
   }
@@ -65,6 +71,7 @@
   server_statistics_fetcher_.Fetch();
   drivetrain_output_fetcher_.Fetch();
   client_statistics_fetcher_.Fetch();
+  gyro_reading_fetcher_.Fetch();
 
   // Estopped
   if (superstructure_status_fetcher_.get() &&
@@ -80,6 +87,23 @@
     return;
   }
 
+  // If the imu gyro readings are not being sent/updated recently
+  if (!gyro_reading_fetcher_.get() ||
+      gyro_reading_fetcher_.context().monotonic_event_time <
+          event_loop_->monotonic_now() - frc971::controls::kLoopFrequency * 10) {
+    if (imu_flash_) {
+      DisplayLed(255, 0, 0);
+    } else {
+      DisplayLed(255, 255, 255);
+    }
+
+    if (imu_counter_ % kFlashIterations == 0) {
+      imu_flash_ = !imu_flash_;
+    }
+    imu_counter_++;
+    return;
+  }
+
   // Pi disconnected
   if ((server_statistics_fetcher_.get() &&
        DisconnectedPiServer(*server_statistics_fetcher_)) ||
diff --git a/y2022/control_loops/superstructure/led_indicator.h b/y2022/control_loops/superstructure/led_indicator.h
index 680b875..0f44788 100644
--- a/y2022/control_loops/superstructure/led_indicator.h
+++ b/y2022/control_loops/superstructure/led_indicator.h
@@ -9,6 +9,7 @@
 #include "frc971/control_loops/control_loops_generated.h"
 #include "frc971/control_loops/drivetrain/drivetrain_output_generated.h"
 #include "frc971/control_loops/profiled_subsystem_generated.h"
+#include "frc971/queues/gyro_generated.h"
 #include "y2022/control_loops/superstructure/superstructure_output_generated.h"
 #include "y2022/control_loops/superstructure/superstructure_status_generated.h"
 
@@ -22,6 +23,7 @@
   //
   // Red: estopped
   // Yellow: not zeroed
+  // Flash red/white: imu disconnected
   // Flash red/green: pi disconnected
   // Purple: driving fast
   //
@@ -48,6 +50,7 @@
 
   ctre::phoenix::led::CANdle candle_{0, ""};
 
+  aos::EventLoop *event_loop_;
   aos::Fetcher<frc971::control_loops::drivetrain::Output>
       drivetrain_output_fetcher_;
   aos::Fetcher<Status> superstructure_status_fetcher_;
@@ -55,7 +58,10 @@
       server_statistics_fetcher_;
   aos::Fetcher<aos::message_bridge::ClientStatistics>
       client_statistics_fetcher_;
+  aos::Fetcher<frc971::sensors::GyroReading> gyro_reading_fetcher_;
 
+  size_t imu_counter_ = 0;
+  bool imu_flash_ = false;
   size_t disconnected_counter_ = 0;
   bool disconnected_flash_ = false;
 };
diff --git a/y2022/control_loops/superstructure/superstructure.cc b/y2022/control_loops/superstructure/superstructure.cc
index 0e71656..15f9c2a 100644
--- a/y2022/control_loops/superstructure/superstructure.cc
+++ b/y2022/control_loops/superstructure/superstructure.cc
@@ -5,6 +5,9 @@
 #include "frc971/zeroing/wrap.h"
 #include "y2022/control_loops/superstructure/collision_avoidance.h"
 
+DEFINE_bool(ignore_distance, false,
+            "If true, ignore distance when shooting and obay joystick_reader");
+
 namespace y2022 {
 namespace control_loops {
 namespace superstructure {
@@ -28,7 +31,8 @@
           event_loop->MakeFetcher<frc971::control_loops::drivetrain::Status>(
               "/drivetrain")),
       can_position_fetcher_(
-          event_loop->MakeFetcher<CANPosition>("/superstructure")) {
+          event_loop->MakeFetcher<CANPosition>("/superstructure")),
+      aimer_(values) {
   event_loop->SetRuntimeRealtimePriority(30);
 }
 
@@ -70,10 +74,10 @@
   const CatapultGoal *catapult_goal = nullptr;
   double roller_speed_compensated_front = 0.0;
   double roller_speed_compensated_back = 0.0;
-  double transfer_roller_speed_front = 0.0;
-  double transfer_roller_speed_back = 0.0;
+  double transfer_roller_speed = 0.0;
   double flipper_arms_voltage = 0.0;
   bool have_active_intake_request = false;
+  bool climber_servo = false;
 
   if (unsafe_goal != nullptr) {
     roller_speed_compensated_front =
@@ -84,8 +88,9 @@
         unsafe_goal->roller_speed_back() -
         std::min(velocity * unsafe_goal->roller_speed_compensation(), 0.0);
 
-    transfer_roller_speed_front = unsafe_goal->transfer_roller_speed_front();
-    transfer_roller_speed_back = unsafe_goal->transfer_roller_speed_back();
+    transfer_roller_speed = unsafe_goal->transfer_roller_speed();
+
+    climber_servo = unsafe_goal->climber_servo();
 
     turret_goal =
         unsafe_goal->auto_aim() ? auto_aim_goal : unsafe_goal->turret();
@@ -94,8 +99,9 @@
 
     constants::Values::ShotParams shot_params;
     const double distance_to_goal = aimer_.DistanceToGoal();
-    if (unsafe_goal->auto_aim() && values_->shot_interpolation_table.GetInRange(
-                                       distance_to_goal, &shot_params)) {
+    if (!FLAGS_ignore_distance && unsafe_goal->auto_aim() &&
+        values_->shot_interpolation_table.GetInRange(distance_to_goal,
+                                                     &shot_params)) {
       flatbuffers::FlatBufferBuilder *catapult_goal_fbb =
           catapult_goal_buffer.fbb();
       std::optional<flatbuffers::Offset<
@@ -175,13 +181,13 @@
   }
 
   // Check if we're either spitting of have lost the ball.
-  if (transfer_roller_speed_front < 0.0 ||
+  if ((transfer_roller_speed < 0.0 && front_intake_has_ball_) ||
       timestamp >
           front_intake_beambreak_timer_ + constants::Values::kBallLostTime()) {
     front_intake_has_ball_ = false;
   }
 
-  if (transfer_roller_speed_back < 0.0 ||
+  if ((transfer_roller_speed > 0.0 && back_intake_has_ball_) ||
       timestamp >
           back_intake_beambreak_timer_ + constants::Values::kBallLostTime()) {
     back_intake_has_ball_ = false;
@@ -194,18 +200,18 @@
   if (front_intake_has_ball_) {
     roller_speed_compensated_front = 0.0;
     if (position->intake_beambreak_front()) {
-      transfer_roller_speed_front = -wiggle_voltage;
+      transfer_roller_speed = -wiggle_voltage;
     } else {
-      transfer_roller_speed_front = wiggle_voltage;
+      transfer_roller_speed = wiggle_voltage;
     }
   }
 
   if (back_intake_has_ball_) {
     roller_speed_compensated_back = 0.0;
     if (position->intake_beambreak_back()) {
-      transfer_roller_speed_back = -wiggle_voltage;
+      transfer_roller_speed = wiggle_voltage;
     } else {
-      transfer_roller_speed_back = wiggle_voltage;
+      transfer_roller_speed = -wiggle_voltage;
     }
   }
 
@@ -244,6 +250,10 @@
        .turret_position = turret_.estimated_position(),
        .shooting = true});
 
+  // Dont shoot if the robot is moving faster than this
+  constexpr double kMaxShootSpeed = 2.7;
+  const bool moving_too_fast = std::abs(robot_velocity()) > kMaxShootSpeed;
+
   switch (state_) {
     case SuperstructureState::IDLE: {
       // Only change the turret's goal loading position when idle, to prevent us
@@ -257,11 +267,12 @@
       }
       // When IDLE with no specific intake button pressed, allow the goal
       // message to override the intaking stuff.
-      if (have_active_intake_request || turret_goal == nullptr) {
+      if (have_active_intake_request || (turret_goal == nullptr)) {
         turret_goal = &turret_loading_goal_buffer.message();
       }
 
       if (!front_intake_has_ball_ && !back_intake_has_ball_) {
+        last_shot_angle_ = std::nullopt;
         break;
       }
 
@@ -291,11 +302,9 @@
 
       // Transfer rollers and flipper arm belt on
       if (turret_intake_state_ == RequestedIntake::kFront) {
-        transfer_roller_speed_front =
-            constants::Values::kTransferRollerVoltage();
+        transfer_roller_speed = constants::Values::kTransferRollerVoltage();
       } else {
-        transfer_roller_speed_back =
-            constants::Values::kTransferRollerVoltage();
+        transfer_roller_speed = -constants::Values::kTransferRollerVoltage();
       }
       flipper_arms_voltage = constants::Values::kFlipperFeedVoltage();
 
@@ -330,6 +339,13 @@
     }
     case SuperstructureState::LOADED: {
       if (unsafe_goal != nullptr) {
+        if (turret_goal == nullptr) {
+          if (last_shot_angle_) {
+            turret_loading_goal_buffer.mutable_message()->mutate_unsafe_goal(
+                *last_shot_angle_);
+          }
+          turret_goal = &turret_loading_goal_buffer.message();
+        }
         if (unsafe_goal->cancel_shot()) {
           // Cancel the shot process
           state_ = SuperstructureState::IDLE;
@@ -345,9 +361,24 @@
       break;
     }
     case SuperstructureState::SHOOTING: {
+      if (turret_goal == nullptr) {
+        if (last_shot_angle_) {
+          turret_loading_goal_buffer.mutable_message()->mutate_unsafe_goal(
+              *last_shot_angle_);
+        }
+        turret_goal = &turret_loading_goal_buffer.message();
+        last_shot_angle_ = turret_goal->unsafe_goal();
+      } else {
+        last_shot_angle_ = std::nullopt;
+      }
+      const bool turret_near_goal =
+          turret_goal != nullptr &&
+          std::abs(turret_goal->unsafe_goal() - turret_.position()) <
+              kTurretGoalThreshold;
+
       // Don't open the flippers until the turret's ready: give them as little
-      // time to get bumped as possible.
-      if (!turret_near_goal || collided) {
+      // time to get bumped as possible. Or moving to fast.
+      if (!turret_near_goal || collided || moving_too_fast) {
         break;
       }
 
@@ -468,9 +499,15 @@
   if (output != nullptr) {
     output_struct.roller_voltage_front = roller_speed_compensated_front;
     output_struct.roller_voltage_back = roller_speed_compensated_back;
-    output_struct.transfer_roller_voltage_front = transfer_roller_speed_front;
-    output_struct.transfer_roller_voltage_back = transfer_roller_speed_back;
+    output_struct.transfer_roller_voltage = transfer_roller_speed;
     output_struct.flipper_arms_voltage = flipper_arms_voltage;
+    if (climber_servo) {
+      output_struct.climber_servo_left = 0.0;
+      output_struct.climber_servo_right = 1.0;
+    } else {
+      output_struct.climber_servo_left = 1.0;
+      output_struct.climber_servo_right = 0.0;
+    }
 
     output->CheckOk(output->Send(Output::Pack(*output->fbb(), &output_struct)));
   }
@@ -504,6 +541,7 @@
   status_builder.add_flippers_open(flippers_open_);
   status_builder.add_reseating_in_catapult(reseating_in_catapult_);
   status_builder.add_fire(fire_);
+  status_builder.add_moving_too_fast(moving_too_fast);
   status_builder.add_ready_to_fire(state_ == SuperstructureState::LOADED &&
                                    turret_near_goal && !collided);
   status_builder.add_state(state_);
diff --git a/y2022/control_loops/superstructure/superstructure.h b/y2022/control_loops/superstructure/superstructure.h
index 11cd38f..14fa8ab 100644
--- a/y2022/control_loops/superstructure/superstructure.h
+++ b/y2022/control_loops/superstructure/superstructure.h
@@ -94,6 +94,7 @@
   SuperstructureState state_ = SuperstructureState::IDLE;
   bool front_intake_has_ball_ = false;
   bool back_intake_has_ball_ = false;
+  std::optional<double> last_shot_angle_ = std::nullopt;
   RequestedIntake turret_intake_state_ = RequestedIntake::kFront;
 
   DISALLOW_COPY_AND_ASSIGN(Superstructure);
diff --git a/y2022/control_loops/superstructure/superstructure_goal.fbs b/y2022/control_loops/superstructure/superstructure_goal.fbs
index 7227dc2..4d4a81f 100644
--- a/y2022/control_loops/superstructure/superstructure_goal.fbs
+++ b/y2022/control_loops/superstructure/superstructure_goal.fbs
@@ -26,6 +26,10 @@
   // Height of the climber above rest point
   climber:frc971.control_loops.StaticZeroingSingleDOFProfiledSubsystemGoal (id: 0);
 
+  // True if the servo should be released.
+  // Positive is moving it out
+  climber_servo:bool (id: 15);
+
   // Goal angles of intake joints.
   // Positive is out, 0 is up.
   intake_front:frc971.control_loops.StaticZeroingSingleDOFProfiledSubsystemGoal (id: 1);
@@ -37,8 +41,10 @@
   roller_speed_front:double (id: 3);
   roller_speed_back:double (id: 4);
 
-  transfer_roller_speed_front:double (id: 5);
-  transfer_roller_speed_back:double (id: 12);
+  // Positive is intaking front and spitting back, negative is the opposite
+  transfer_roller_speed:double (id: 5);
+  // Not used anymore - just one transfer roller speed to control both
+  transfer_roller_speed_back:double (id: 12, deprecated);
 
   // Factor to multiply robot velocity by and add to roller voltage.
   roller_speed_compensation:double (id: 6);
diff --git a/y2022/control_loops/superstructure/superstructure_lib_test.cc b/y2022/control_loops/superstructure/superstructure_lib_test.cc
index 9288da1..7123a47 100644
--- a/y2022/control_loops/superstructure/superstructure_lib_test.cc
+++ b/y2022/control_loops/superstructure/superstructure_lib_test.cc
@@ -753,7 +753,7 @@
   SetEnabled(true);
   WaitUntilZeroed();
 
-  SendRobotVelocity(3.0);
+  SendRobotVelocity(1.0);
 
   constexpr double kTurretGoal = 2.0;
   {
@@ -778,10 +778,7 @@
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 12.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 12.0);
 
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_front(),
-            0.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_back(),
-            0.0);
+  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage(), 0.0);
   EXPECT_EQ(superstructure_status_fetcher_->state(), SuperstructureState::IDLE);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
             IntakeState::NO_BALL);
@@ -822,10 +819,8 @@
             IntakeState::INTAKE_FRONT_BALL);
   EXPECT_EQ(superstructure_output_fetcher_->flipper_arms_voltage(),
             constants::Values::kFlipperFeedVoltage());
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_front(),
+  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage(),
             constants::Values::kTransferRollerVoltage());
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_back(),
-            0.0);
   EXPECT_NEAR(superstructure_status_fetcher_->turret()->position(),
               constants::Values::kTurretFrontIntakePos(), 0.001);
   EXPECT_EQ(superstructure_status_fetcher_->shot_count(), 0);
@@ -843,10 +838,7 @@
   ASSERT_TRUE(superstructure_status_fetcher_.Fetch());
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 12.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 12.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_front(),
-            0.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_back(),
-            0.0);
+  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage(), 0.0);
   EXPECT_EQ(superstructure_status_fetcher_->state(),
             SuperstructureState::LOADING);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
@@ -865,10 +857,7 @@
   ASSERT_TRUE(superstructure_status_fetcher_.Fetch());
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 12.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 12.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_front(),
-            0.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_back(),
-            0.0);
+  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage(), 0.0);
   EXPECT_EQ(superstructure_status_fetcher_->state(),
             SuperstructureState::LOADED);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
@@ -884,10 +873,7 @@
   ASSERT_TRUE(superstructure_status_fetcher_.Fetch());
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 12.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 12.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_front(),
-            0.0);
-  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage_back(),
-            0.0);
+  EXPECT_EQ(superstructure_output_fetcher_->transfer_roller_voltage(), 0.0);
   EXPECT_EQ(superstructure_status_fetcher_->state(),
             SuperstructureState::LOADED);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
@@ -908,14 +894,12 @@
   ASSERT_TRUE(superstructure_output_fetcher_.Fetch());
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 12.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 0.0);
-  EXPECT_TRUE(superstructure_output_fetcher_->transfer_roller_voltage_back() !=
+  EXPECT_TRUE(superstructure_output_fetcher_->transfer_roller_voltage() !=
                   0.0 &&
-              superstructure_output_fetcher_->transfer_roller_voltage_back() <=
+              superstructure_output_fetcher_->transfer_roller_voltage() <=
                   constants::Values::kTransferRollerWiggleVoltage() &&
-              superstructure_output_fetcher_->transfer_roller_voltage_back() >=
+              superstructure_output_fetcher_->transfer_roller_voltage() >=
                   -constants::Values::kTransferRollerWiggleVoltage());
-  EXPECT_EQ(0.0,
-            superstructure_output_fetcher_->transfer_roller_voltage_front());
   EXPECT_EQ(superstructure_status_fetcher_->state(),
             SuperstructureState::LOADED);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
@@ -963,14 +947,12 @@
   ASSERT_TRUE(superstructure_status_fetcher_.Fetch());
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_front(), 0.0);
   EXPECT_EQ(superstructure_output_fetcher_->roller_voltage_back(), 0.0);
-  EXPECT_TRUE(superstructure_output_fetcher_->transfer_roller_voltage_back() !=
+  EXPECT_TRUE(superstructure_output_fetcher_->transfer_roller_voltage() !=
                   0.0 &&
-              superstructure_output_fetcher_->transfer_roller_voltage_back() <=
+              superstructure_output_fetcher_->transfer_roller_voltage() <=
                   constants::Values::kTransferRollerWiggleVoltage() &&
-              superstructure_output_fetcher_->transfer_roller_voltage_back() >=
+              superstructure_output_fetcher_->transfer_roller_voltage() >=
                   -constants::Values::kTransferRollerWiggleVoltage());
-  EXPECT_EQ(0.0,
-            superstructure_output_fetcher_->transfer_roller_voltage_front());
   EXPECT_EQ(superstructure_status_fetcher_->state(),
             SuperstructureState::SHOOTING);
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
@@ -999,7 +981,7 @@
   EXPECT_EQ(superstructure_status_fetcher_->intake_state(),
             IntakeState::INTAKE_BACK_BALL);
   EXPECT_NEAR(superstructure_status_fetcher_->turret()->position(),
-              constants::Values::kTurretBackIntakePos(), 0.001);
+              -constants::Values::kTurretBackIntakePos(), 0.001);
 
   // Since the intake beambreak hasn't triggered in a while, it should realize
   // the ball was lost.
@@ -1212,8 +1194,7 @@
 
   RunFor(chrono::milliseconds(2000));
   ASSERT_TRUE(superstructure_status_fetcher_.Fetch());
-  EXPECT_EQ(superstructure_status_fetcher_->state(),
-            SuperstructureState::IDLE);
+  EXPECT_EQ(superstructure_status_fetcher_->state(), SuperstructureState::IDLE);
 }
 
 // Test that we are able to signal that the ball was preloaded
diff --git a/y2022/control_loops/superstructure/superstructure_output.fbs b/y2022/control_loops/superstructure/superstructure_output.fbs
index af6c292..4ba9034 100644
--- a/y2022/control_loops/superstructure/superstructure_output.fbs
+++ b/y2022/control_loops/superstructure/superstructure_output.fbs
@@ -5,6 +5,10 @@
   // - is down + is up
   climber_voltage:double (id: 0);
 
+  // Position of the climber servo from 0 to 1
+  climber_servo_left:double (id: 10);
+  climber_servo_right:double (id: 11);
+
   // Voltage of the flipper arms falcons
   // - is feed + is open
   flipper_arms_voltage:double (id: 1);
@@ -26,8 +30,9 @@
   // positive is pulling into the robot
   roller_voltage_front:double (id: 6);
   roller_voltage_back:double (id: 7);
-  transfer_roller_voltage_front:double (id: 8);
-  transfer_roller_voltage_back:double (id: 9);
+  transfer_roller_voltage:double (id: 8);
+  // Only using one transfer roller voltage now
+  transfer_roller_voltage_back:double (id: 9, deprecated);
 }
 
 root_type Output;
diff --git a/y2022/control_loops/superstructure/superstructure_status.fbs b/y2022/control_loops/superstructure/superstructure_status.fbs
index 06fddd0..9cf9a5f 100644
--- a/y2022/control_loops/superstructure/superstructure_status.fbs
+++ b/y2022/control_loops/superstructure/superstructure_status.fbs
@@ -57,6 +57,8 @@
   reseating_in_catapult:bool (id: 13);
   // Whether the turret is ready for firing
   ready_to_fire:bool (id: 20);
+  // Whether the robot is moving too fast to shoot
+  moving_too_fast:bool (id: 21);
   // Whether the catapult was told to fire,
   // meaning that the turret and flippers are ready for firing
   // and we were asked to fire. Different from fire flag in goal.
diff --git a/y2022/control_loops/superstructure/turret/aiming.cc b/y2022/control_loops/superstructure/turret/aiming.cc
index e1d24f8..5fe8a2c 100644
--- a/y2022/control_loops/superstructure/turret/aiming.cc
+++ b/y2022/control_loops/superstructure/turret/aiming.cc
@@ -1,6 +1,5 @@
 #include "y2022/control_loops/superstructure/turret/aiming.h"
 
-#include "y2022/constants.h"
 #include "y2022/control_loops/drivetrain/drivetrain_base.h"
 
 namespace y2022 {
@@ -13,10 +12,6 @@
 using frc971::control_loops::aiming::RobotState;
 
 namespace {
-// Average speed-over-ground of the ball on its way to the target. Our current
-// model assumes constant ball velocity regardless of shot distance.
-constexpr double kBallSpeedOverGround = 12.0;  // m/s
-
 // If the turret is at zero, then it will be at this angle at which the shot
 // will leave the robot. I.e., if the turret is at zero, then the shot will go
 // straight out the back of the robot.
@@ -43,7 +38,8 @@
 }
 }  // namespace
 
-Aimer::Aimer() : goal_(MakePrefilledGoal()) {}
+Aimer::Aimer(std::shared_ptr<const constants::Values> constants)
+    : constants_(constants), goal_(MakePrefilledGoal()) {}
 
 void Aimer::Update(const Status *status, ShotMode shot_mode) {
   const Pose robot_pose({status->x(), status->y(), 0}, status->theta());
@@ -56,15 +52,18 @@
   const double xdot = linear_angular(0) * std::cos(status->theta());
   const double ydot = linear_angular(0) * std::sin(status->theta());
 
-  current_goal_ =
-      frc971::control_loops::aiming::AimerGoal(
-          ShotConfig{goal, shot_mode, constants::Values::kTurretRange(),
-                     kBallSpeedOverGround,
-                     /*wrap_mode=*/0.0, kTurretZeroOffset},
-          RobotState{robot_pose,
-                     {xdot, ydot},
-                     linear_angular(1),
-                     goal_.message().unsafe_goal()});
+  // Use the previous shot distance to estimate the speed-over-ground of the
+  // ball.
+  current_goal_ = frc971::control_loops::aiming::AimerGoal(
+      ShotConfig{goal, shot_mode, constants_->kTurretRange(),
+                 constants_->shot_velocity_interpolation_table
+                     .Get(current_goal_.target_distance)
+                     .shot_speed_over_ground,
+                 /*wrap_mode=*/0.0, kTurretZeroOffset},
+      RobotState{robot_pose,
+                 {xdot, ydot},
+                 linear_angular(1),
+                 goal_.message().unsafe_goal()});
 
   goal_.mutable_message()->mutate_unsafe_goal(current_goal_.position);
   goal_.mutable_message()->mutate_goal_velocity(
diff --git a/y2022/control_loops/superstructure/turret/aiming.h b/y2022/control_loops/superstructure/turret/aiming.h
index 9494103..4eabe3e 100644
--- a/y2022/control_loops/superstructure/turret/aiming.h
+++ b/y2022/control_loops/superstructure/turret/aiming.h
@@ -2,10 +2,11 @@
 #define Y2022_CONTROL_LOOPS_SUPERSTRUCTURE_TURRET_AIMING_H_
 
 #include "aos/flatbuffers.h"
+#include "frc971/control_loops/aiming/aiming.h"
 #include "frc971/control_loops/drivetrain/drivetrain_status_generated.h"
 #include "frc971/control_loops/pose.h"
 #include "frc971/control_loops/profiled_subsystem_generated.h"
-#include "frc971/control_loops/aiming/aiming.h"
+#include "y2022/constants.h"
 #include "y2022/control_loops/superstructure/superstructure_status_generated.h"
 
 namespace y2022::control_loops::superstructure::turret {
@@ -19,7 +20,7 @@
   typedef frc971::control_loops::drivetrain::Status Status;
   typedef frc971::control_loops::aiming::ShotMode ShotMode;
 
-  Aimer();
+  Aimer(std::shared_ptr<const constants::Values> constants);
 
   void Update(const Status *status, ShotMode shot_mode);
 
@@ -32,6 +33,7 @@
       flatbuffers::FlatBufferBuilder *fbb) const;
 
  private:
+  std::shared_ptr<const constants::Values> constants_;
   aos::FlatbufferDetachedBuffer<Goal> goal_;
   frc971::control_loops::aiming::TurretGoal current_goal_;
 };
diff --git a/y2022/image_streamer/BUILD b/y2022/image_streamer/BUILD
new file mode 100644
index 0000000..0305dc1
--- /dev/null
+++ b/y2022/image_streamer/BUILD
@@ -0,0 +1,55 @@
+load("//aos/seasocks:gen_embedded.bzl", "gen_embedded")
+
+gen_embedded(
+    name = "gen_embedded",
+    srcs = glob(
+        include = ["www_defaults/**/*"],
+        exclude = ["www/**/*"],
+    ),
+)
+
+filegroup(
+    name = "image_streamer_start",
+    srcs = ["image_streamer_start.sh"],
+    visibility = ["//visibility:public"],
+)
+
+cc_binary(
+    name = "image_streamer",
+    srcs = ["image_streamer.cc"],
+    args = [
+        "--data_dir=y2022/image_streamer/www",
+    ],
+    copts = [
+        "-Wno-cast-align",
+    ],
+    data = [
+        "//y2022:aos_config",
+        "//y2022/image_streamer/www:files",
+        "//y2022/image_streamer/www:main_bundle.min.js",
+    ],
+    target_compatible_with = select({
+        "@platforms//cpu:x86_64": [],
+        "@platforms//cpu:aarch64": [],
+        "//conditions:default": ["@platforms//:incompatible"],
+    }) + [
+        "@platforms//os:linux",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":gen_embedded",
+        "//aos:configuration_fbs",
+        "//aos:init",
+        "//aos/events:glib_main_loop",
+        "//aos/events:shm_event_loop",
+        "//aos/network:connect_fbs",
+        "//aos/network:web_proxy_fbs",
+        "//aos/seasocks:seasocks_logger",
+        "//frc971/vision:vision_fbs",
+        "//third_party:gstreamer",
+        "//third_party/seasocks",
+        "@com_github_google_flatbuffers//:flatbuffers",
+        "@com_github_google_glog//:glog",
+        "@com_google_absl//absl/strings:str_format",
+    ],
+)
diff --git a/y2022/image_streamer/image_streamer.cc b/y2022/image_streamer/image_streamer.cc
new file mode 100644
index 0000000..9a990ed
--- /dev/null
+++ b/y2022/image_streamer/image_streamer.cc
@@ -0,0 +1,597 @@
+#define GST_USE_UNSTABLE_API
+#define GST_DISABLE_REGISTRY 1
+
+#include <glib-unix.h>
+#include <glib.h>
+#include <gst/app/app.h>
+#include <gst/gst.h>
+#include <gst/sdp/sdp.h>
+#include <gst/webrtc/icetransport.h>
+#include <gst/webrtc/webrtc.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <map>
+#include <thread>
+
+#include "absl/strings/str_format.h"
+#include "aos/events/glib_main_loop.h"
+#include "aos/events/shm_event_loop.h"
+#include "aos/init.h"
+#include "aos/network/web_proxy_generated.h"
+#include "aos/seasocks/seasocks_logger.h"
+#include "flatbuffers/flatbuffers.h"
+#include "frc971/vision/vision_generated.h"
+#include "gflags/gflags.h"
+#include "glog/logging.h"
+#include "internal/Embedded.h"
+#include "seasocks/Server.h"
+#include "seasocks/StringUtil.h"
+#include "seasocks/WebSocket.h"
+
+extern "C" {
+GST_PLUGIN_STATIC_DECLARE(app);
+GST_PLUGIN_STATIC_DECLARE(coreelements);
+GST_PLUGIN_STATIC_DECLARE(dtls);
+GST_PLUGIN_STATIC_DECLARE(nice);
+GST_PLUGIN_STATIC_DECLARE(rtp);
+GST_PLUGIN_STATIC_DECLARE(rtpmanager);
+GST_PLUGIN_STATIC_DECLARE(srtp);
+GST_PLUGIN_STATIC_DECLARE(webrtc);
+GST_PLUGIN_STATIC_DECLARE(video4linux2);
+GST_PLUGIN_STATIC_DECLARE(videoconvert);
+GST_PLUGIN_STATIC_DECLARE(videoparsersbad);
+GST_PLUGIN_STATIC_DECLARE(videorate);
+GST_PLUGIN_STATIC_DECLARE(videoscale);
+GST_PLUGIN_STATIC_DECLARE(videotestsrc);
+GST_PLUGIN_STATIC_DECLARE(x264);
+}
+DEFINE_string(config, "y2022/aos_config.json",
+              "Name of the config file to replay using.");
+DEFINE_string(device, "/dev/video0", "Camera fd");
+DEFINE_string(data_dir, "image_streamer_www",
+              "Directory to serve data files from");
+DEFINE_int32(width, 400, "Image width");
+DEFINE_int32(height, 300, "Image height");
+DEFINE_int32(framerate, 25, "Framerate (FPS)");
+DEFINE_int32(brightness, 50, "Camera brightness");
+DEFINE_int32(exposure, 300, "Manual exposure");
+DEFINE_int32(bitrate, 500000, "H264 encode bitrate");
+DEFINE_int32(min_port, 5800, "Min rtp port");
+DEFINE_int32(max_port, 5810, "Max rtp port");
+
+class Connection;
+
+using aos::web_proxy::Payload;
+using aos::web_proxy::SdpType;
+using aos::web_proxy::WebSocketIce;
+using aos::web_proxy::WebSocketMessage;
+using aos::web_proxy::WebSocketSdp;
+
+// Basic class that handles receiving new websocket connections. Creates a new
+// Connection to manage the rest of the negotiation and data passing. When the
+// websocket closes, it deletes the Connection.
+class WebsocketHandler : public ::seasocks::WebSocket::Handler {
+ public:
+  WebsocketHandler(aos::ShmEventLoop *event_loop, ::seasocks::Server *server);
+  ~WebsocketHandler() override;
+
+  void onConnect(::seasocks::WebSocket *sock) override;
+  void onData(::seasocks::WebSocket *sock, const uint8_t *data,
+              size_t size) override;
+  void onDisconnect(::seasocks::WebSocket *sock) override;
+
+ private:
+  static GstFlowReturn OnSampleCallback(GstElement *, gpointer user_data) {
+    static_cast<WebsocketHandler *>(user_data)->OnSample();
+    return GST_FLOW_OK;
+  }
+
+  void OnSample();
+
+  std::map<::seasocks::WebSocket *, std::unique_ptr<Connection>> connections_;
+  ::seasocks::Server *server_;
+  GstElement *pipeline_;
+  GstElement *appsink_;
+
+  aos::Sender<frc971::vision::CameraImage> sender_;
+};
+
+// Seasocks requires that sends happen on the correct thread. This class takes a
+// detached buffer to send on a specific websocket connection and sends it when
+// seasocks is ready.
+class UpdateData : public ::seasocks::Server::Runnable {
+ public:
+  UpdateData(::seasocks::WebSocket *websocket,
+             flatbuffers::DetachedBuffer &&buffer)
+      : sock_(websocket), buffer_(std::move(buffer)) {}
+  ~UpdateData() override = default;
+  UpdateData(const UpdateData &) = delete;
+  UpdateData &operator=(const UpdateData &) = delete;
+
+  void run() override { sock_->send(buffer_.data(), buffer_.size()); }
+
+ private:
+  ::seasocks::WebSocket *sock_;
+  const flatbuffers::DetachedBuffer buffer_;
+};
+
+class Connection {
+ public:
+  Connection(::seasocks::WebSocket *sock, ::seasocks::Server *server);
+
+  ~Connection();
+
+  void HandleWebSocketData(const uint8_t *data, size_t size);
+
+  void OnSample(GstSample *sample);
+
+ private:
+  static void OnOfferCreatedCallback(GstPromise *promise, gpointer user_data) {
+    static_cast<Connection *>(user_data)->OnOfferCreated(promise);
+  }
+
+  static void OnNegotiationNeededCallback(GstElement *, gpointer user_data) {
+    static_cast<Connection *>(user_data)->OnNegotiationNeeded();
+  }
+
+  static void OnIceCandidateCallback(GstElement *, guint mline_index,
+                                     gchar *candidate, gpointer user_data) {
+    static_cast<Connection *>(user_data)->OnIceCandidate(mline_index,
+                                                         candidate);
+  }
+
+  void OnOfferCreated(GstPromise *promise);
+  void OnNegotiationNeeded();
+  void OnIceCandidate(guint mline_index, gchar *candidate);
+
+  ::seasocks::WebSocket *sock_;
+  ::seasocks::Server *server_;
+
+  GstElement *pipeline_;
+  GstElement *webrtcbin_;
+  GstElement *appsrc_;
+
+  bool first_sample_ = true;
+};
+
+WebsocketHandler::WebsocketHandler(aos::ShmEventLoop *event_loop,
+                                   ::seasocks::Server *server)
+    : server_(server),
+      sender_(event_loop->MakeSender<frc971::vision::CameraImage>("/camera")) {
+  GError *error = NULL;
+
+  // Create pipeline to read from camera, pack into rtp stream, and dump stream
+  // to callback.
+  // v4l2 device should already be configured with correct bitrate from
+  // v4l2-ctl. do-timestamp marks the time the frame was taken to track when it
+  // should be dropped under latency.
+
+  // With the Pi's hardware encoder, we can encode and package the stream once
+  // and the clients will jump in at any point unsynchronized. With the stream
+  // from x264enc this doesn't seem to work. For now, just reencode for each
+  // client since we don't expect more than 1 or 2.
+
+  pipeline_ = gst_parse_launch(
+      absl::StrFormat("v4l2src device=%s do-timestamp=true "
+                      "extra-controls=\"c,brightness=%d,auto_exposure=1,"
+                      "exposure_time_absolute=%d\" ! "
+                      "video/x-raw,width=%d,height=%d,framerate=%d/"
+                      "1,format=YUY2 ! appsink "
+                      "name=appsink "
+                      "emit-signals=true sync=false async=false "
+                      "caps=video/x-raw,format=YUY2",
+                      FLAGS_device, FLAGS_brightness, FLAGS_exposure,
+                      FLAGS_width, FLAGS_height, FLAGS_framerate)
+          .c_str(),
+      &error);
+
+  if (error != NULL) {
+    LOG(FATAL) << "Could not create v4l2 pipeline: " << error->message;
+  }
+
+  appsink_ = gst_bin_get_by_name(GST_BIN(pipeline_), "appsink");
+  if (appsink_ == NULL) {
+    LOG(FATAL) << "Could not get appsink";
+  }
+
+  g_signal_connect(appsink_, "new-sample",
+                   G_CALLBACK(WebsocketHandler::OnSampleCallback),
+                   static_cast<gpointer>(this));
+
+  gst_element_set_state(pipeline_, GST_STATE_PLAYING);
+}
+
+WebsocketHandler::~WebsocketHandler() {
+  if (pipeline_ != NULL) {
+    gst_element_set_state(GST_ELEMENT(pipeline_), GST_STATE_NULL);
+    gst_object_unref(GST_OBJECT(pipeline_));
+    gst_object_unref(GST_OBJECT(appsink_));
+  }
+}
+
+void WebsocketHandler::onConnect(::seasocks::WebSocket *sock) {
+  std::unique_ptr<Connection> conn =
+      std::make_unique<Connection>(sock, server_);
+  connections_.insert({sock, std::move(conn)});
+}
+
+void WebsocketHandler::onData(::seasocks::WebSocket *sock, const uint8_t *data,
+                              size_t size) {
+  connections_[sock]->HandleWebSocketData(data, size);
+}
+
+void WebsocketHandler::OnSample() {
+  GstSample *sample = gst_app_sink_pull_sample(GST_APP_SINK(appsink_));
+  if (sample == NULL) {
+    LOG(WARNING) << "Received null sample";
+    return;
+  }
+
+  for (auto iter = connections_.begin(); iter != connections_.end(); ++iter) {
+    iter->second->OnSample(sample);
+  }
+
+  {
+    const GstCaps *caps = CHECK_NOTNULL(gst_sample_get_caps(sample));
+    CHECK_GT(gst_caps_get_size(caps), 0U);
+    const GstStructure *str = gst_caps_get_structure(caps, 0);
+
+    gint width;
+    gint height;
+
+    CHECK(gst_structure_get_int(str, "width", &width));
+    CHECK(gst_structure_get_int(str, "height", &height));
+
+    GstBuffer *buffer = CHECK_NOTNULL(gst_sample_get_buffer(sample));
+
+    const gsize size = gst_buffer_get_size(buffer);
+
+    auto builder = sender_.MakeBuilder();
+
+    uint8_t *image_data;
+    auto image_offset =
+        builder.fbb()->CreateUninitializedVector(size, &image_data);
+    gst_buffer_extract(buffer, 0, image_data, size);
+
+    auto image_builder = builder.MakeBuilder<frc971::vision::CameraImage>();
+    image_builder.add_rows(height);
+    image_builder.add_cols(width);
+    image_builder.add_data(image_offset);
+
+    builder.CheckOk(builder.Send(image_builder.Finish()));
+  }
+
+  gst_sample_unref(sample);
+}
+
+void WebsocketHandler::onDisconnect(::seasocks::WebSocket *sock) {
+  connections_.erase(sock);
+}
+
+Connection::Connection(::seasocks::WebSocket *sock, ::seasocks::Server *server)
+    : sock_(sock), server_(server) {
+  GError *error = NULL;
+
+  // Build pipeline to read data from application into pipeline, place in
+  // webrtcbin group, and stream.
+
+  pipeline_ = gst_parse_launch(
+      // aggregate-mode should be zero-latency but this drops the stream on
+      // bitrate spikes for some reason - probably the weak CPU on the pi.
+      absl::StrFormat(
+          "webrtcbin name=webrtcbin appsrc "
+          "name=appsrc block=false "
+          "is-live=true "
+          "format=3 max-buffers=0 leaky-type=2 "
+          "caps=video/x-raw,width=%d,height=%d,format=YUY2 ! videoconvert ! "
+          "x264enc bitrate=%d speed-preset=ultrafast "
+          "tune=zerolatency key-int-max=15 sliced-threads=true ! "
+          "video/x-h264,profile=constrained-baseline ! h264parse ! "
+          "rtph264pay "
+          "config-interval=-1 name=payloader aggregate-mode=none ! "
+          "application/"
+          "x-rtp,media=video,encoding-name=H264,payload=96,clock-rate=90000 !"
+          "webrtcbin. ",
+          FLAGS_width, FLAGS_height, FLAGS_bitrate / 1000)
+          .c_str(),
+      &error);
+
+  if (error != NULL) {
+    LOG(FATAL) << "Could not create WebRTC pipeline: " << error->message;
+  }
+
+  webrtcbin_ = gst_bin_get_by_name(GST_BIN(pipeline_), "webrtcbin");
+  if (webrtcbin_ == NULL) {
+    LOG(FATAL) << "Could not initialize webrtcbin";
+  }
+
+  appsrc_ = gst_bin_get_by_name(GST_BIN(pipeline_), "appsrc");
+  if (appsrc_ == NULL) {
+    LOG(FATAL) << "Could not initialize appsrc";
+  }
+
+  {
+    GArray *transceivers;
+    g_signal_emit_by_name(webrtcbin_, "get-transceivers", &transceivers);
+    if (transceivers == NULL || transceivers->len <= 0) {
+      LOG(FATAL) << "Could not initialize transceivers";
+    }
+
+    GstWebRTCRTPTransceiver *trans =
+        g_array_index(transceivers, GstWebRTCRTPTransceiver *, 0);
+    g_object_set(trans, "direction",
+                 GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY, nullptr);
+
+    g_array_unref(transceivers);
+  }
+
+  {
+    GstObject *ice = nullptr;
+    g_object_get(G_OBJECT(webrtcbin_), "ice-agent", &ice, nullptr);
+    CHECK_NOTNULL(ice);
+
+    g_object_set(ice, "min-rtp-port", FLAGS_min_port, "max-rtp-port",
+                 FLAGS_max_port, nullptr);
+
+    // We don't need upnp on a local network.
+    {
+      GstObject *nice = nullptr;
+      g_object_get(ice, "agent", &nice, nullptr);
+      CHECK_NOTNULL(nice);
+
+      g_object_set(nice, "upnp", false, nullptr);
+      g_object_unref(nice);
+    }
+
+    gst_object_unref(ice);
+  }
+
+  g_signal_connect(webrtcbin_, "on-negotiation-needed",
+                   G_CALLBACK(Connection::OnNegotiationNeededCallback),
+                   static_cast<gpointer>(this));
+
+  g_signal_connect(webrtcbin_, "on-ice-candidate",
+                   G_CALLBACK(Connection::OnIceCandidateCallback),
+                   static_cast<gpointer>(this));
+
+  gst_element_set_state(pipeline_, GST_STATE_READY);
+  gst_element_set_state(pipeline_, GST_STATE_PLAYING);
+}
+
+Connection::~Connection() {
+  if (pipeline_ != NULL) {
+    gst_element_set_state(pipeline_, GST_STATE_NULL);
+
+    gst_object_unref(GST_OBJECT(webrtcbin_));
+    gst_object_unref(GST_OBJECT(pipeline_));
+    gst_object_unref(GST_OBJECT(appsrc_));
+  }
+}
+
+void Connection::OnSample(GstSample *sample) {
+  GstFlowReturn response =
+      gst_app_src_push_sample(GST_APP_SRC(appsrc_), sample);
+  if (response != GST_FLOW_OK) {
+    LOG(WARNING) << "Sample pushed, did not receive OK";
+  }
+
+  // Since the stream is already running (the camera turns on with
+  // image_streamer) we need to tell the new appsrc where
+  // we are starting in the stream so it can catch up immediately.
+  if (first_sample_) {
+    GstPad *src = gst_element_get_static_pad(appsrc_, "src");
+    if (src == NULL) {
+      return;
+    }
+
+    GstSegment *segment = gst_sample_get_segment(sample);
+    GstBuffer *buffer = gst_sample_get_buffer(sample);
+
+    guint64 offset = gst_segment_to_running_time(segment, GST_FORMAT_TIME,
+                                                 GST_BUFFER_PTS(buffer));
+    LOG(INFO) << "Fixing offset " << offset;
+    gst_pad_set_offset(src, -offset);
+
+    gst_object_unref(GST_OBJECT(src));
+    first_sample_ = false;
+  }
+}
+
+void Connection::OnOfferCreated(GstPromise *promise) {
+  LOG(INFO) << "OnOfferCreated";
+
+  GstWebRTCSessionDescription *offer = NULL;
+  gst_structure_get(gst_promise_get_reply(promise), "offer",
+                    GST_TYPE_WEBRTC_SESSION_DESCRIPTION, &offer, NULL);
+  gst_promise_unref(promise);
+
+  {
+    std::unique_ptr<GstPromise, decltype(&gst_promise_unref)>
+        local_desc_promise(gst_promise_new(), &gst_promise_unref);
+    g_signal_emit_by_name(webrtcbin_, "set-local-description", offer,
+                          local_desc_promise.get());
+    gst_promise_interrupt(local_desc_promise.get());
+  }
+
+  GstSDPMessage *sdp_msg = offer->sdp;
+  std::string sdp_str(gst_sdp_message_as_text(sdp_msg));
+
+  LOG(INFO) << "Negotiation offer created:\n" << sdp_str;
+
+  flatbuffers::FlatBufferBuilder fbb(512);
+  flatbuffers::Offset<WebSocketSdp> sdp_fb =
+      CreateWebSocketSdpDirect(fbb, SdpType::OFFER, sdp_str.c_str());
+  flatbuffers::Offset<WebSocketMessage> answer_message =
+      CreateWebSocketMessage(fbb, Payload::WebSocketSdp, sdp_fb.Union());
+  fbb.Finish(answer_message);
+
+  server_->execute(std::make_shared<UpdateData>(sock_, fbb.Release()));
+}
+
+void Connection::OnNegotiationNeeded() {
+  LOG(INFO) << "OnNegotiationNeeded";
+
+  GstPromise *promise;
+  promise = gst_promise_new_with_change_func(Connection::OnOfferCreatedCallback,
+                                             static_cast<gpointer>(this), NULL);
+  g_signal_emit_by_name(G_OBJECT(webrtcbin_), "create-offer", NULL, promise);
+}
+
+void Connection::OnIceCandidate(guint mline_index, gchar *candidate) {
+  LOG(INFO) << "OnIceCandidate";
+
+  flatbuffers::FlatBufferBuilder fbb(512);
+
+  auto ice_fb_builder = WebSocketIce::Builder(fbb);
+  ice_fb_builder.add_sdp_m_line_index(mline_index);
+  ice_fb_builder.add_sdp_mid(fbb.CreateString("video0"));
+  ice_fb_builder.add_candidate(
+      fbb.CreateString(static_cast<char *>(candidate)));
+  flatbuffers::Offset<WebSocketIce> ice_fb = ice_fb_builder.Finish();
+
+  flatbuffers::Offset<WebSocketMessage> ice_message =
+      CreateWebSocketMessage(fbb, Payload::WebSocketIce, ice_fb.Union());
+  fbb.Finish(ice_message);
+
+  server_->execute(std::make_shared<UpdateData>(sock_, fbb.Release()));
+
+  g_signal_emit_by_name(webrtcbin_, "add-ice-candidate", mline_index,
+                        candidate);
+}
+
+void Connection::HandleWebSocketData(const uint8_t *data, size_t /* size*/) {
+  LOG(INFO) << "HandleWebSocketData";
+
+  const WebSocketMessage *message =
+      flatbuffers::GetRoot<WebSocketMessage>(data);
+
+  switch (message->payload_type()) {
+    case Payload::WebSocketSdp: {
+      const WebSocketSdp *offer = message->payload_as_WebSocketSdp();
+      if (offer->type() != SdpType::ANSWER) {
+        LOG(WARNING) << "Expected SDP message type \"answer\"";
+        break;
+      }
+      const flatbuffers::String *sdp_string = offer->payload();
+
+      LOG(INFO) << "Received SDP:\n" << sdp_string->c_str();
+
+      GstSDPMessage *sdp;
+      GstSDPResult status = gst_sdp_message_new(&sdp);
+      if (status != GST_SDP_OK) {
+        LOG(WARNING) << "Could not create SDP message";
+        break;
+      }
+
+      status = gst_sdp_message_parse_buffer((const guint8 *)sdp_string->c_str(),
+                                            sdp_string->size(), sdp);
+
+      if (status != GST_SDP_OK) {
+        LOG(WARNING) << "Could not parse SDP string";
+        break;
+      }
+
+      std::unique_ptr<GstWebRTCSessionDescription,
+                      decltype(&gst_webrtc_session_description_free)>
+          answer(gst_webrtc_session_description_new(GST_WEBRTC_SDP_TYPE_ANSWER,
+                                                    sdp),
+                 &gst_webrtc_session_description_free);
+      std::unique_ptr<GstPromise, decltype(&gst_promise_unref)> promise(
+          gst_promise_new(), &gst_promise_unref);
+      g_signal_emit_by_name(webrtcbin_, "set-remote-description", answer.get(),
+                            promise.get());
+      gst_promise_interrupt(promise.get());
+
+      break;
+    }
+    case Payload::WebSocketIce: {
+      const WebSocketIce *ice = message->payload_as_WebSocketIce();
+      if (!ice->has_candidate() || ice->candidate()->size() == 0) {
+        LOG(WARNING) << "Received ICE message without candidate";
+        break;
+      }
+
+      const gchar *candidate =
+          static_cast<const gchar *>(ice->candidate()->c_str());
+      guint mline_index = ice->sdp_m_line_index();
+
+      LOG(INFO) << "Received ICE candidate with mline index " << mline_index
+                << "; candidate: " << candidate;
+
+      g_signal_emit_by_name(webrtcbin_, "add-ice-candidate", mline_index,
+                            candidate);
+
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void RegisterPlugins() {
+  GST_PLUGIN_STATIC_REGISTER(app);
+  GST_PLUGIN_STATIC_REGISTER(coreelements);
+  GST_PLUGIN_STATIC_REGISTER(dtls);
+  GST_PLUGIN_STATIC_REGISTER(nice);
+  GST_PLUGIN_STATIC_REGISTER(rtp);
+  GST_PLUGIN_STATIC_REGISTER(rtpmanager);
+  GST_PLUGIN_STATIC_REGISTER(srtp);
+  GST_PLUGIN_STATIC_REGISTER(webrtc);
+  GST_PLUGIN_STATIC_REGISTER(video4linux2);
+  GST_PLUGIN_STATIC_REGISTER(videoconvert);
+  GST_PLUGIN_STATIC_REGISTER(videoparsersbad);
+  GST_PLUGIN_STATIC_REGISTER(videorate);
+  GST_PLUGIN_STATIC_REGISTER(videoscale);
+  GST_PLUGIN_STATIC_REGISTER(videotestsrc);
+  GST_PLUGIN_STATIC_REGISTER(x264);
+}
+
+int main(int argc, char **argv) {
+  aos::InitGoogle(&argc, &argv);
+
+  findEmbeddedContent("");
+
+  std::string openssl_env = "OPENSSL_CONF=\"\"";
+  putenv(const_cast<char *>(openssl_env.c_str()));
+
+  putenv(const_cast<char *>("GST_REGISTRY_DISABLE=yes"));
+
+  gst_init(&argc, &argv);
+  RegisterPlugins();
+
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config =
+      aos::configuration::ReadConfig(FLAGS_config);
+  aos::ShmEventLoop event_loop(&config.message());
+
+  {
+    aos::GlibMainLoop main_loop(&event_loop);
+
+    seasocks::Server server(::std::shared_ptr<seasocks::Logger>(
+        new ::aos::seasocks::SeasocksLogger(seasocks::Logger::Level::Info)));
+
+    LOG(INFO) << "Serving from " << FLAGS_data_dir;
+
+    auto websocket_handler =
+        std::make_shared<WebsocketHandler>(&event_loop, &server);
+    server.addWebSocketHandler("/ws", websocket_handler);
+
+    server.startListening(1180);
+    server.setStaticPath(FLAGS_data_dir.c_str());
+
+    aos::internal::EPoll *epoll = event_loop.epoll();
+
+    epoll->OnReadable(server.fd(), [&server] {
+      CHECK(::seasocks::Server::PollResult::Continue == server.poll(0));
+    });
+
+    event_loop.Run();
+
+    epoll->DeleteFd(server.fd());
+    server.terminate();
+  }
+
+  gst_deinit();
+
+  return 0;
+}
diff --git a/y2022/image_streamer/image_streamer_start.sh b/y2022/image_streamer/image_streamer_start.sh
new file mode 100755
index 0000000..9e6de58
--- /dev/null
+++ b/y2022/image_streamer/image_streamer_start.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Some configurations to avoid dropping frames
+# 640x480@30fps, 400x300@60fps.
+# Bitrate 500000-1500000
+DEVICE=/dev/video0
+WIDTH=640
+HEIGHT=480
+BITRATE=1500000
+FRAMERATE=30
+EXPOSURE=200
+
+# Handle weirdness with openssl and gstreamer
+export OPENSSL_CONF=""
+
+# Enable for verbose logging
+#export GST_DEBUG=4
+
+export LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu/gstreamer-1.0
+
+exec ./image_streamer --device=$DEVICE --width=$WIDTH --height=$HEIGHT --framerate=$FRAMERATE --bitrate=$BITRATE --exposure=$EXPOSURE --config=$HOME/bin/aos_config.json
+
diff --git a/y2022/image_streamer/www/BUILD b/y2022/image_streamer/www/BUILD
new file mode 100644
index 0000000..908c5b4
--- /dev/null
+++ b/y2022/image_streamer/www/BUILD
@@ -0,0 +1,52 @@
+load("@npm//@bazel/typescript:index.bzl", "ts_library")
+load("//tools/build_rules:js.bzl", "rollup_bundle")
+load("//frc971/downloader:downloader.bzl", "aos_downloader_dir")
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "files",
+    srcs = glob([
+        "**/*.html",
+        "**/*.css",
+    ]),
+)
+
+ts_library(
+    name = "proxy",
+    srcs = [
+        "proxy.ts",
+    ],
+    deps = [
+        "//aos/network:web_proxy_ts_fbs",
+        "@com_github_google_flatbuffers//ts:flatbuffers_ts",
+    ],
+)
+
+ts_library(
+    name = "main",
+    srcs = [
+        "main.ts",
+    ],
+    deps = [
+        ":proxy",
+    ],
+)
+
+rollup_bundle(
+    name = "main_bundle",
+    entry_point = "main.ts",
+    deps = [
+        "main",
+    ],
+)
+
+aos_downloader_dir(
+    name = "www_files",
+    srcs = [
+        ":files",
+        ":main_bundle.min.js",
+    ],
+    dir = "image_streamer_www",
+    visibility = ["//visibility:public"],
+)
diff --git a/y2022/image_streamer/www/index.html b/y2022/image_streamer/www/index.html
new file mode 100644
index 0000000..f71750d
--- /dev/null
+++ b/y2022/image_streamer/www/index.html
@@ -0,0 +1,89 @@
+<html>
+  <head>
+    <script type="text/javascript"></script>
+    <script src="main_bundle.min.js" defer></script>
+    <style>
+      code {
+        background-color: #eee;
+      }
+    </style>
+  </head>
+  <body>
+    <div>
+      <video id="stream" autoplay playsinline muted style="height: 95%">
+        Your browser does not support video
+      </video>
+    </div>
+    <p>
+      Stats: <span id="stats_protocol">Not connected</span>, <span id="stats_bps"></span> Kibit/s, <span id="stats_fps"></span> fps
+    </p>
+    <span>
+      <div id="bad_remote_port_error" style="display: none">
+        <p>
+          Remote emitted a port <span id="bad_remote_port_port"></span> which may not be supported over the FMS.
+          Try running <code>image_streamer</code> with <code>-min_port=</code> and <code>-max_port=</code>
+        </p>
+      </div>
+      <div id="bad_local_port_error" style="display: none">
+        <p>
+          Local emitted a port <span id="bad_local_port_port"></span> which may not be supported over the FMS, or may fallback to TCP.
+        </p>
+        <p>To fix:</p>
+        <ul>
+          <li>
+            Firefox: Not supported
+          </li>
+          <li>Chrome:
+            <ul>
+              <li>
+                Windows:
+                <br>
+                Add registry entry <code>Software\Policies\Google\Chrome\WebRtcUdpPortRange = "5800-5810"</code>
+                <br>
+                (For Chromium, <code>Software\Policies\Chromium\WebRtcUdpPortRange</code>)
+              </li>
+              <li>
+                Linux:
+                <br>
+                <code>mkdir -p /etc/opt/chrome/policies/managed</code> OR <code>mkdir -p /etc/chromium/policies/managed</code> OR, ON SOME DISTROS <code>mkdir -p /etc/chromium-browser/policies/managed</code>
+                <br>
+                <code>echo '{"WebRtcUdpPortRange": "5800-5810"}' &gt; /etc/&lt;&gt;/policies/managed/webrtc_port_policy.json</code>
+              </li>
+            </ul>
+          </li>
+        </ul>
+      </div>
+      <div id="bad_remote_address_error" style="display: none">
+        <p>Remote emitted an address <span id="bad_remote_address_address"></span> which requires mDNS resolution. This may not be supported.</p>
+      </div>
+      <div id="bad_local_address_error" style="display: none">
+        <p>Local emitted an address <span id="bad_local_address_address"></span> which requires mDNS resolution. This may not be supported.</p>
+        <p>To fix:</p>
+        <ul>
+          <li>
+            Firefox: Navigate to <a href="about:config">about:config</a> (May need to select and copy into new tab).
+            Set <code>media.peerconnection.ice.obfuscate_host_addresses</code> to <code>false</code>.
+          </li>
+          <li>Chrome:
+            <ul>
+              <li>
+                Windows:
+                <br>
+                Add registry entry <code>Software\Policies\Google\Chrome\WebRtcLocalIpsAllowedUrls\1 = "*<span class="page_hostname"></span>*"</code>
+                <br>
+                (For Chromium, <code>Software\Policies\Chromium\WebRtcLocalIpsAllowedUrls\1</code>)
+              </li>
+              <li>
+                Linux:
+                <br>
+                <code>mkdir -p /etc/opt/chrome/policies/managed</code> OR <code>mkdir -p /etc/chromium/policies/managed</code> OR, ON SOME DISTROS <code>mkdir -p /etc/chromium-browser/policies/managed</code>
+                <br>
+                <code>echo '{"WebRtcLocalIpsAllowedUrls": ["*<span class="page_hostname"></span>*"]}' &gt; /etc/&lt;&gt;/policies/managed/webrtc_policy.json</code>
+              </li>
+            </ul>
+          </li>
+        </ul>
+      </div>
+    </span>
+  </body>
+</html>
diff --git a/y2022/image_streamer/www/main.ts b/y2022/image_streamer/www/main.ts
new file mode 100644
index 0000000..5a3165e
--- /dev/null
+++ b/y2022/image_streamer/www/main.ts
@@ -0,0 +1,5 @@
+import {Connection} from './proxy';
+
+const conn = new Connection();
+
+conn.connect();
diff --git a/y2022/image_streamer/www/proxy.ts b/y2022/image_streamer/www/proxy.ts
new file mode 100644
index 0000000..bfe8135
--- /dev/null
+++ b/y2022/image_streamer/www/proxy.ts
@@ -0,0 +1,248 @@
+import {Builder, ByteBuffer} from 'flatbuffers';
+import {Payload, SdpType, WebSocketIce, WebSocketMessage, WebSocketSdp} from 'org_frc971/aos/network/web_proxy_generated';
+
+// Port 9 is used to indicate an active (outgoing) TCP connection. The server
+// would send a corresponding candidate with the actual TCP port it is
+// listening on. Ignore NaN since it doesn't tell us anything about whether the
+// port selected will have issues through the FMS firewall.
+function validPort(port: number): boolean {
+  return Number.isNaN(port) || port == 9 || (port >= 1180 && port <= 1190) ||
+      (port >= 5800 && port <= 5810);
+}
+
+// Some browsers don't support the port property so provide our own function
+// to get it.
+function getIcePort(candidate: RTCIceCandidate): number {
+  if (candidate.port === undefined) {
+    return Number(candidate.candidate.split(' ')[5]);
+  } else {
+    return candidate.port;
+  }
+}
+
+function isMdnsAddress(address: string): boolean {
+  return address.includes('.local');
+}
+
+function getIceAddress(candidate: RTCIceCandidate): string {
+  if (candidate.address === undefined) {
+    return candidate.candidate.split(' ')[4];
+  } else {
+    return candidate.address;
+  }
+}
+
+export class Connection {
+  private webSocketConnection: WebSocket|null = null;
+  private rtcPeerConnection: RTCPeerConnection|null = null;
+  private html5VideoElement: HTMLMediaElement|null = null;
+  private webSocketUrl: string;
+  private statsInterval: number;
+
+  private candidateNominatedId: string;
+  private lastRtpTimestamp: number = 0;
+  private lastBytesReceived: number = 0;
+  private lastFramesDecoded: number = 0;
+
+
+  constructor() {
+    const server = location.host;
+    this.webSocketUrl = `ws://${server}/ws`;
+
+    for (let elem of document.getElementsByClassName('page_hostname')) {
+      (elem as HTMLElement).innerText = location.hostname;
+    }
+  }
+
+  connect(): void {
+    this.html5VideoElement =
+        (document.getElementById('stream') as HTMLMediaElement);
+
+    this.webSocketConnection = new WebSocket(this.webSocketUrl);
+    this.webSocketConnection.binaryType = 'arraybuffer';
+    this.webSocketConnection.addEventListener(
+        'message', (e) => this.onWebSocketMessage(e));
+  }
+
+
+  checkRemoteCandidate(candidate: RTCIceCandidate) {
+    const port = getIcePort(candidate);
+    if (!validPort(port)) {
+      document.getElementById('bad_remote_port_port').innerText =
+          port.toString();
+      document.getElementById('bad_remote_port_error').style['display'] =
+          'inherit';
+    }
+    const address = getIceAddress(candidate);
+    if (isMdnsAddress(address)) {
+      document.getElementById('bad_remote_address_address').innerText = address;
+      document.getElementById('bad_remote_address_error').style['display'] =
+          'inherit';
+    }
+  }
+
+  checkLocalCandidate(candidate: RTCIceCandidate) {
+    const port = getIcePort(candidate);
+    if (!validPort(port)) {
+      document.getElementById('bad_local_port_port').innerText =
+          port.toString();
+      document.getElementById('bad_local_port_error').style['display'] =
+          'inherit';
+    }
+    const address = getIceAddress(candidate);
+    if (isMdnsAddress(address)) {
+      document.getElementById('bad_local_address_address').innerText = address;
+      document.getElementById('bad_local_address_error').style['display'] =
+          'inherit';
+    }
+  }
+
+  onLocalDescription(desc: RTCSessionDescriptionInit): void {
+    console.log('Local description: ' + JSON.stringify(desc));
+    this.rtcPeerConnection.setLocalDescription(desc).then(() => {
+      const builder = new Builder(512);
+      const sdpFb = WebSocketSdp.createWebSocketSdp(
+          builder, SdpType.ANSWER, builder.createString(desc.sdp));
+      const message = WebSocketMessage.createWebSocketMessage(
+          builder, Payload.WebSocketSdp, sdpFb);
+      builder.finish(message);
+      const array = builder.asUint8Array();
+
+      this.webSocketConnection.send(array.buffer.slice(array.byteOffset));
+    });
+  }
+
+  onIncomingSDP(sdp: RTCSessionDescriptionInit): void {
+    console.log('Incoming SDP: ' + JSON.stringify(sdp));
+    this.rtcPeerConnection.setRemoteDescription(sdp);
+    this.rtcPeerConnection.createAnswer().then(
+        (e) => this.onLocalDescription(e));
+  }
+
+  onIncomingICE(ice: RTCIceCandidateInit): void {
+    let candidate = new RTCIceCandidate(ice);
+    console.log('Incoming ICE: ' + JSON.stringify(ice));
+    this.rtcPeerConnection.addIceCandidate(candidate);
+
+    // If end of candidates, won't have a port.
+    if (candidate.candidate !== '') {
+      this.checkRemoteCandidate(candidate);
+    }
+  }
+
+  onRequestStats(track: MediaStreamTrack): void {
+    this.rtcPeerConnection.getStats(track).then((stats) => {
+      // getStats returns a list of stats of various types in an implementation
+      // defined order. We would like to get the protocol in use. This is found
+      // in remote-candidate. However, (again, implementation defined), some
+      // browsers return only remote-candidate's in use, while others return all
+      // of them that attempted negotiation. To figure this out, look at the
+      // currently nominated candidate-pair, then match up it's remote with a
+      // remote-candidate we see later. Since the order isn't defined, store the
+      // id in this in case the remote-candidate comes before candidate-pair.
+
+      for (let dict of stats.values()) {
+        if (dict.type === 'candidate-pair' && dict.nominated) {
+          this.candidateNominatedId = dict.remoteCandidateId;
+        }
+        if (dict.type === 'remote-candidate' &&
+            dict.id === this.candidateNominatedId) {
+          document.getElementById('stats_protocol').innerText = dict.protocol;
+        }
+        if (dict.type === 'inbound-rtp') {
+          const timestamp = dict.timestamp;
+          const bytes_now = dict.bytesReceived;
+          const frames_decoded = dict.framesDecoded;
+
+          document.getElementById('stats_bps').innerText =
+              Math.round(
+                      (bytes_now - this.lastBytesReceived) * 8 /* bits */ /
+                      1024 /* kbits */ / (timestamp - this.lastRtpTimestamp) *
+                      1000 /* ms */)
+                  .toString();
+
+          document.getElementById('stats_fps').innerText =
+              (Math.round(
+                   (frames_decoded - this.lastFramesDecoded) /
+                   (timestamp - this.lastRtpTimestamp) * 1000 /* ms */ * 10) /
+               10).toString();
+
+
+          this.lastRtpTimestamp = timestamp;
+          this.lastBytesReceived = bytes_now;
+          this.lastFramesDecoded = frames_decoded;
+        }
+      }
+    });
+  }
+
+  onAddRemoteStream(event: RTCTrackEvent): void {
+    const stream = event.streams[0];
+    this.html5VideoElement.srcObject = stream;
+
+    const track = stream.getTracks()[0];
+    this.statsInterval =
+        window.setInterval(() => this.onRequestStats(track), 1000);
+  }
+
+  onIceCandidate(event: RTCPeerConnectionIceEvent): void {
+    if (event.candidate == null) {
+      return;
+    }
+
+    console.log(
+        'Sending ICE candidate out: ' + JSON.stringify(event.candidate));
+
+    const builder = new Builder(512);
+    const iceFb = WebSocketIce.createWebSocketIce(
+        builder, builder.createString(event.candidate.candidate), null,
+        event.candidate.sdpMLineIndex);
+    const message = WebSocketMessage.createWebSocketMessage(
+        builder, Payload.WebSocketIce, iceFb);
+    builder.finish(message);
+    const array = builder.asUint8Array();
+
+    this.webSocketConnection.send(array.buffer.slice(array.byteOffset));
+
+    // If end of candidates, won't have a port.
+    if (event.candidate.candidate !== '') {
+      this.checkLocalCandidate(event.candidate);
+    }
+  }
+
+  // When we receive a websocket message, we need to determine what type it is
+  // and handle appropriately. Either by setting the remote description or
+  // adding the remote ice candidate.
+  onWebSocketMessage(e: MessageEvent): void {
+    const buffer = new Uint8Array(e.data)
+    const fbBuffer = new ByteBuffer(buffer);
+    const message = WebSocketMessage.getRootAsWebSocketMessage(fbBuffer);
+
+    if (!this.rtcPeerConnection) {
+      this.rtcPeerConnection = new RTCPeerConnection();
+      this.rtcPeerConnection.ontrack = (e) => this.onAddRemoteStream(e);
+      this.rtcPeerConnection.onicecandidate = (e) => this.onIceCandidate(e);
+    }
+
+    switch (message.payloadType()) {
+      case Payload.WebSocketSdp:
+        const sdpFb = message.payload(new WebSocketSdp());
+        const sdp:
+            RTCSessionDescriptionInit = {type: 'offer', sdp: sdpFb.payload()};
+
+        this.onIncomingSDP(sdp);
+        break;
+      case Payload.WebSocketIce:
+        const iceFb = message.payload(new WebSocketIce());
+        const candidate = {} as RTCIceCandidateInit;
+        candidate.candidate = iceFb.candidate();
+        candidate.sdpMLineIndex = iceFb.sdpMLineIndex();
+        candidate.sdpMid = iceFb.sdpMid();
+        this.onIncomingICE(candidate);
+        break;
+      default:
+        console.log('got an unknown message');
+        break;
+    }
+  }
+}
diff --git a/y2022/image_streamer/www_defaults/_404.png b/y2022/image_streamer/www_defaults/_404.png
new file mode 100644
index 0000000..8a43cb8
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_404.png
Binary files differ
diff --git a/y2022/image_streamer/www_defaults/_error.css b/y2022/image_streamer/www_defaults/_error.css
new file mode 100644
index 0000000..8238d6d
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_error.css
@@ -0,0 +1,33 @@
+body {
+    font-family: segoe ui, tahoma, arial, sans-serif;
+    color: #ffffff;
+    background-color: #c21e29;
+    text-align: center;
+}
+
+a {
+    color: #ffff00;
+}
+
+.footer {
+    font-style: italic;
+}
+
+.message {
+    display: inline-block;
+    border: 1px solid white;
+    padding: 50px;
+    font-size: 20px;
+}
+
+.headline {
+    padding: 50px;
+    font-weight: bold;
+    font-size: 32px;
+}
+
+.footer {
+    padding-top: 50px;
+    font-size: 12px;
+}
+
diff --git a/y2022/image_streamer/www_defaults/_error.html b/y2022/image_streamer/www_defaults/_error.html
new file mode 100644
index 0000000..ecf5e32
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_error.html
@@ -0,0 +1,15 @@
+<html DOCTYPE=html>
+<head>
+  <title>%%ERRORCODE%% - %%MESSAGE%% - Keep Calm And Carry On!</title>
+  <link href="/_error.css" rel="stylesheet">
+</head>
+<body>
+  <div class="message">
+    <img src="/_404.png" height="200" width="107">
+    <div class="headline">%%ERRORCODE%% &#8212; %%MESSAGE%%</div>
+    <div class="info">%%BODY%%</div>
+  </div>
+
+  <div class="footer">Powered by <a href="https://github.com/mattgodbolt/seasocks">SeaSocks</a></div>
+</body>
+</html>
diff --git a/y2022/image_streamer/www_defaults/_jquery.min.js b/y2022/image_streamer/www_defaults/_jquery.min.js
new file mode 100644
index 0000000..f78f96a
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_jquery.min.js
@@ -0,0 +1,16 @@
+/*!
+ * jQuery JavaScript Library v1.5.2
+ * http://jquery.com/
+ *
+ * Copyright 2011, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ * Copyright 2011, The Dojo Foundation
+ * Released under the MIT, BSD, and GPL Licenses.
+ *
+ * Date: Thu Mar 31 15:28:23 2011 -0400
+ */
+(function(a,b){function ci(a){return d.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cf(a){if(!b_[a]){var b=d("<"+a+">").appendTo("body"),c=b.css("display");b.remove();if(c==="none"||c==="")c="block";b_[a]=c}return b_[a]}function ce(a,b){var c={};d.each(cd.concat.apply([],cd.slice(0,b)),function(){c[this]=a});return c}function b$(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function bZ(){try{return new a.XMLHttpRequest}catch(b){}}function bY(){d(a).unload(function(){for(var a in bW)bW[a](0,1)})}function bS(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var e=a.dataTypes,f={},g,h,i=e.length,j,k=e[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h==="string"&&(f[h.toLowerCase()]=a.converters[h]);l=k,k=e[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=f[m]||f["* "+k];if(!n){p=b;for(o in f){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=f[j[1]+" "+k];if(p){o=f[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&d.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function bR(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function bQ(a,b,c,e){if(d.isArray(b)&&b.length)d.each(b,function(b,f){c||bs.test(a)?e(a,f):bQ(a+"["+(typeof f==="object"||d.isArray(f)?b:"")+"]",f,c,e)});else if(c||b==null||typeof b!=="object")e(a,b);else if(d.isArray(b)||d.isEmptyObject(b))e(a,"");else for(var f in b)bQ(a+"["+f+"]",b[f],c,e)}function bP(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bJ,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l==="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=bP(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=bP(a,c,d,e,"*",g));return l}function bO(a){return function(b,c){typeof b!=="string"&&(c=b,b="*");if(d.isFunction(c)){var e=b.toLowerCase().split(bD),f=0,g=e.length,h,i,j;for(;f<g;f++)h=e[f],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function bq(a,b,c){var e=b==="width"?bk:bl,f=b==="width"?a.offsetWidth:a.offsetHeight;if(c==="border")return f;d.each(e,function(){c||(f-=parseFloat(d.css(a,"padding"+this))||0),c==="margin"?f+=parseFloat(d.css(a,"margin"+this))||0:f-=parseFloat(d.css(a,"border"+this+"Width"))||0});return f}function bc(a,b){b.src?d.ajax({url:b.src,async:!1,dataType:"script"}):d.globalEval(b.text||b.textContent||b.innerHTML||""),b.parentNode&&b.parentNode.removeChild(b)}function bb(a){return"getElementsByTagName"in a?a.getElementsByTagName("*"):"querySelectorAll"in a?a.querySelectorAll("*"):[]}function ba(a,b){if(b.nodeType===1){var c=b.nodeName.toLowerCase();b.clearAttributes(),b.mergeAttributes(a);if(c==="object")b.outerHTML=a.outerHTML;else if(c!=="input"||a.type!=="checkbox"&&a.type!=="radio"){if(c==="option")b.selected=a.defaultSelected;else if(c==="input"||c==="textarea")b.defaultValue=a.defaultValue}else a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value);b.removeAttribute(d.expando)}}function _(a,b){if(b.nodeType===1&&d.hasData(a)){var c=d.expando,e=d.data(a),f=d.data(b,e);if(e=e[c]){var g=e.events;f=f[c]=d.extend({},e);if(g){delete f.handle,f.events={};for(var h in g)for(var i=0,j=g[h].length;i<j;i++)d.event.add(b,h+(g[h][i].namespace?".":"")+g[h][i].namespace,g[h][i],g[h][i].data)}}}}function $(a,b){return d.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function Q(a,b,c){if(d.isFunction(b))return d.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return d.grep(a,function(a,d){return a===b===c});if(typeof b==="string"){var e=d.grep(a,function(a){return a.nodeType===1});if(L.test(b))return d.filter(b,e,!c);b=d.filter(b,e)}return d.grep(a,function(a,e){return d.inArray(a,b)>=0===c})}function P(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function H(a,b){return(a&&a!=="*"?a+".":"")+b.replace(t,"`").replace(u,"&")}function G(a){var b,c,e,f,g,h,i,j,k,l,m,n,o,p=[],q=[],s=d._data(this,"events");if(a.liveFired!==this&&s&&s.live&&!a.target.disabled&&(!a.button||a.type!=="click")){a.namespace&&(n=new RegExp("(^|\\.)"+a.namespace.split(".").join("\\.(?:.*\\.)?")+"(\\.|$)")),a.liveFired=this;var t=s.live.slice(0);for(i=0;i<t.length;i++)g=t[i],g.origType.replace(r,"")===a.type?q.push(g.selector):t.splice(i--,1);f=d(a.target).closest(q,a.currentTarget);for(j=0,k=f.length;j<k;j++){m=f[j];for(i=0;i<t.length;i++){g=t[i];if(m.selector===g.selector&&(!n||n.test(g.namespace))&&!m.elem.disabled){h=m.elem,e=null;if(g.preType==="mouseenter"||g.preType==="mouseleave")a.type=g.preType,e=d(a.relatedTarget).closest(g.selector)[0];(!e||e!==h)&&p.push({elem:h,handleObj:g,level:m.level})}}}for(j=0,k=p.length;j<k;j++){f=p[j];if(c&&f.level>c)break;a.currentTarget=f.elem,a.data=f.handleObj.data,a.handleObj=f.handleObj,o=f.handleObj.origHandler.apply(f.elem,arguments);if(o===!1||a.isPropagationStopped()){c=f.level,o===!1&&(b=!1);if(a.isImmediatePropagationStopped())break}}return b}}function E(a,c,e){var f=d.extend({},e[0]);f.type=a,f.originalEvent={},f.liveFired=b,d.event.handle.call(c,f),f.isDefaultPrevented()&&e[0].preventDefault()}function y(){return!0}function x(){return!1}function i(a){for(var b in a)if(b!=="toJSON")return!1;return!0}function h(a,c,e){if(e===b&&a.nodeType===1){e=a.getAttribute("data-"+c);if(typeof e==="string"){try{e=e==="true"?!0:e==="false"?!1:e==="null"?null:d.isNaN(e)?g.test(e)?d.parseJSON(e):e:parseFloat(e)}catch(f){}d.data(a,c,e)}else e=b}return e}var c=a.document,d=function(){function G(){if(!d.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(G,1);return}d.ready()}}var d=function(a,b){return new d.fn.init(a,b,g)},e=a.jQuery,f=a.$,g,h=/^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,i=/\S/,j=/^\s+/,k=/\s+$/,l=/\d/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=navigator.userAgent,w,x,y,z=Object.prototype.toString,A=Object.prototype.hasOwnProperty,B=Array.prototype.push,C=Array.prototype.slice,D=String.prototype.trim,E=Array.prototype.indexOf,F={};d.fn=d.prototype={constructor:d,init:function(a,e,f){var g,i,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!e&&c.body){this.context=c,this[0]=c.body,this.selector="body",this.length=1;return this}if(typeof a==="string"){g=h.exec(a);if(!g||!g[1]&&e)return!e||e.jquery?(e||f).find(a):this.constructor(e).find(a);if(g[1]){e=e instanceof d?e[0]:e,k=e?e.ownerDocument||e:c,j=m.exec(a),j?d.isPlainObject(e)?(a=[c.createElement(j[1])],d.fn.attr.call(a,e,!0)):a=[k.createElement(j[1])]:(j=d.buildFragment([g[1]],[k]),a=(j.cacheable?d.clone(j.fragment):j.fragment).childNodes);return d.merge(this,a)}i=c.getElementById(g[2]);if(i&&i.parentNode){if(i.id!==g[2])return f.find(a);this.length=1,this[0]=i}this.context=c,this.selector=a;return this}if(d.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return d.makeArray(a,this)},selector:"",jquery:"1.5.2",length:0,size:function(){return this.length},toArray:function(){return C.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var e=this.constructor();d.isArray(a)?B.apply(e,a):d.merge(e,a),e.prevObject=this,e.context=this.context,b==="find"?e.selector=this.selector+(this.selector?" ":"")+c:b&&(e.selector=this.selector+"."+b+"("+c+")");return e},each:function(a,b){return d.each(this,a,b)},ready:function(a){d.bindReady(),x.done(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(C.apply(this,arguments),"slice",C.call(arguments).join(","))},map:function(a){return this.pushStack(d.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:B,sort:[].sort,splice:[].splice},d.fn.init.prototype=d.fn,d.extend=d.fn.extend=function(){var a,c,e,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i==="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!=="object"&&!d.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){e=i[c],f=a[c];if(i===f)continue;l&&f&&(d.isPlainObject(f)||(g=d.isArray(f)))?(g?(g=!1,h=e&&d.isArray(e)?e:[]):h=e&&d.isPlainObject(e)?e:{},i[c]=d.extend(l,h,f)):f!==b&&(i[c]=f)}return i},d.extend({noConflict:function(b){a.$=f,b&&(a.jQuery=e);return d},isReady:!1,readyWait:1,ready:function(a){a===!0&&d.readyWait--;if(!d.readyWait||a!==!0&&!d.isReady){if(!c.body)return setTimeout(d.ready,1);d.isReady=!0;if(a!==!0&&--d.readyWait>0)return;x.resolveWith(c,[d]),d.fn.trigger&&d(c).trigger("ready").unbind("ready")}},bindReady:function(){if(!x){x=d._Deferred();if(c.readyState==="complete")return setTimeout(d.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",y,!1),a.addEventListener("load",d.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",y),a.attachEvent("onload",d.ready);var b=!1;try{b=a.frameElement==null}catch(e){}c.documentElement.doScroll&&b&&G()}}},isFunction:function(a){return d.type(a)==="function"},isArray:Array.isArray||function(a){return d.type(a)==="array"},isWindow:function(a){return a&&typeof a==="object"&&"setInterval"in a},isNaN:function(a){return a==null||!l.test(a)||isNaN(a)},type:function(a){return a==null?String(a):F[z.call(a)]||"object"},isPlainObject:function(a){if(!a||d.type(a)!=="object"||a.nodeType||d.isWindow(a))return!1;if(a.constructor&&!A.call(a,"constructor")&&!A.call(a.constructor.prototype,"isPrototypeOf"))return!1;var c;for(c in a){}return c===b||A.call(a,c)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw a},parseJSON:function(b){if(typeof b!=="string"||!b)return null;b=d.trim(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return a.JSON&&a.JSON.parse?a.JSON.parse(b):(new Function("return "+b))();d.error("Invalid JSON: "+b)},parseXML:function(b,c,e){a.DOMParser?(e=new DOMParser,c=e.parseFromString(b,"text/xml")):(c=new ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b)),e=c.documentElement,(!e||!e.nodeName||e.nodeName==="parsererror")&&d.error("Invalid XML: "+b);return c},noop:function(){},globalEval:function(a){if(a&&i.test(a)){var b=c.head||c.getElementsByTagName("head")[0]||c.documentElement,e=c.createElement("script");d.support.scriptEval()?e.appendChild(c.createTextNode(a)):e.text=a,b.insertBefore(e,b.firstChild),b.removeChild(e)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,e){var f,g=0,h=a.length,i=h===b||d.isFunction(a);if(e){if(i){for(f in a)if(c.apply(a[f],e)===!1)break}else for(;g<h;)if(c.apply(a[g++],e)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(var j=a[0];g<h&&c.call(j,g,j)!==!1;j=a[++g]){}return a},trim:D?function(a){return a==null?"":D.call(a)}:function(a){return a==null?"":(a+"").replace(j,"").replace(k,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var e=d.type(a);a.length==null||e==="string"||e==="function"||e==="regexp"||d.isWindow(a)?B.call(c,a):d.merge(c,a)}return c},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var c=0,d=b.length;c<d;c++)if(b[c]===a)return c;return-1},merge:function(a,c){var d=a.length,e=0;if(typeof c.length==="number")for(var f=c.length;e<f;e++)a[d++]=c[e];else while(c[e]!==b)a[d++]=c[e++];a.length=d;return a},grep:function(a,b,c){var d=[],e;c=!!c;for(var f=0,g=a.length;f<g;f++)e=!!b(a[f],f),c!==e&&d.push(a[f]);return d},map:function(a,b,c){var d=[],e;for(var f=0,g=a.length;f<g;f++)e=b(a[f],f,c),e!=null&&(d[d.length]=e);return d.concat.apply([],d)},guid:1,proxy:function(a,c,e){arguments.length===2&&(typeof c==="string"?(e=a,a=e[c],c=b):c&&!d.isFunction(c)&&(e=c,c=b)),!c&&a&&(c=function(){return a.apply(e||this,arguments)}),a&&(c.guid=a.guid=a.guid||c.guid||d.guid++);return c},access:function(a,c,e,f,g,h){var i=a.length;if(typeof c==="object"){for(var j in c)d.access(a,j,c[j],f,g,e);return a}if(e!==b){f=!h&&f&&d.isFunction(e);for(var k=0;k<i;k++)g(a[k],c,f?e.call(a[k],k,g(a[k],c)):e,h);return a}return i?g(a[0],c):b},now:function(){return(new Date).getTime()},uaMatch:function(a){a=a.toLowerCase();var b=r.exec(a)||s.exec(a)||t.exec(a)||a.indexOf("compatible")<0&&u.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},sub:function(){function a(b,c){return new a.fn.init(b,c)}d.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.subclass=this.subclass,a.fn.init=function b(b,c){c&&c instanceof d&&!(c instanceof a)&&(c=a(c));return d.fn.init.call(this,b,c,e)},a.fn.init.prototype=a.fn;var e=a(c);return a},browser:{}}),d.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){F["[object "+b+"]"]=b.toLowerCase()}),w=d.uaMatch(v),w.browser&&(d.browser[w.browser]=!0,d.browser.version=w.version),d.browser.webkit&&(d.browser.safari=!0),E&&(d.inArray=function(a,b){return E.call(b,a)}),i.test(" ")&&(j=/^[\s\xA0]+/,k=/[\s\xA0]+$/),g=d(c),c.addEventListener?y=function(){c.removeEventListener("DOMContentLoaded",y,!1),d.ready()}:c.attachEvent&&(y=function(){c.readyState==="complete"&&(c.detachEvent("onreadystatechange",y),d.ready())});return d}(),e="then done fail isResolved isRejected promise".split(" "),f=[].slice;d.extend({_Deferred:function(){var a=[],b,c,e,f={done:function(){if(!e){var c=arguments,g,h,i,j,k;b&&(k=b,b=0);for(g=0,h=c.length;g<h;g++)i=c[g],j=d.type(i),j==="array"?f.done.apply(f,i):j==="function"&&a.push(i);k&&f.resolveWith(k[0],k[1])}return this},resolveWith:function(d,f){if(!e&&!b&&!c){f=f||[],c=1;try{while(a[0])a.shift().apply(d,f)}finally{b=[d,f],c=0}}return this},resolve:function(){f.resolveWith(this,arguments);return this},isResolved:function(){return c||b},cancel:function(){e=1,a=[];return this}};return f},Deferred:function(a){var b=d._Deferred(),c=d._Deferred(),f;d.extend(b,{then:function(a,c){b.done(a).fail(c);return this},fail:c.done,rejectWith:c.resolveWith,reject:c.resolve,isRejected:c.isResolved,promise:function(a){if(a==null){if(f)return f;f=a={}}var c=e.length;while(c--)a[e[c]]=b[e[c]];return a}}),b.done(c.cancel).fail(b.cancel),delete b.cancel,a&&a.call(b,b);return b},when:function(a){function i(a){return function(c){b[a]=arguments.length>1?f.call(arguments,0):c,--g||h.resolveWith(h,f.call(b,0))}}var b=arguments,c=0,e=b.length,g=e,h=e<=1&&a&&d.isFunction(a.promise)?a:d.Deferred();if(e>1){for(;c<e;c++)b[c]&&d.isFunction(b[c].promise)?b[c].promise().then(i(c),h.reject):--g;g||h.resolveWith(h,b)}else h!==a&&h.resolveWith(h,e?[a]:[]);return h.promise()}}),function(){d.support={};var b=c.createElement("div");b.style.display="none",b.innerHTML="   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";var e=b.getElementsByTagName("*"),f=b.getElementsByTagName("a")[0],g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=b.getElementsByTagName("input")[0];if(e&&e.length&&f){d.support={leadingWhitespace:b.firstChild.nodeType===3,tbody:!b.getElementsByTagName("tbody").length,htmlSerialize:!!b.getElementsByTagName("link").length,style:/red/.test(f.getAttribute("style")),hrefNormalized:f.getAttribute("href")==="/a",opacity:/^0.55$/.test(f.style.opacity),cssFloat:!!f.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,deleteExpando:!0,optDisabled:!1,checkClone:!1,noCloneEvent:!0,noCloneChecked:!0,boxModel:null,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableHiddenOffsets:!0,reliableMarginRight:!0},i.checked=!0,d.support.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,d.support.optDisabled=!h.disabled;var j=null;d.support.scriptEval=function(){if(j===null){var b=c.documentElement,e=c.createElement("script"),f="script"+d.now();try{e.appendChild(c.createTextNode("window."+f+"=1;"))}catch(g){}b.insertBefore(e,b.firstChild),a[f]?(j=!0,delete a[f]):j=!1,b.removeChild(e)}return j};try{delete b.test}catch(k){d.support.deleteExpando=!1}!b.addEventListener&&b.attachEvent&&b.fireEvent&&(b.attachEvent("onclick",function l(){d.support.noCloneEvent=!1,b.detachEvent("onclick",l)}),b.cloneNode(!0).fireEvent("onclick")),b=c.createElement("div"),b.innerHTML="<input type='radio' name='radiotest' checked='checked'/>";var m=c.createDocumentFragment();m.appendChild(b.firstChild),d.support.checkClone=m.cloneNode(!0).cloneNode(!0).lastChild.checked,d(function(){var a=c.createElement("div"),b=c.getElementsByTagName("body")[0];if(b){a.style.width=a.style.paddingLeft="1px",b.appendChild(a),d.boxModel=d.support.boxModel=a.offsetWidth===2,"zoom"in a.style&&(a.style.display="inline",a.style.zoom=1,d.support.inlineBlockNeedsLayout=a.offsetWidth===2,a.style.display="",a.innerHTML="<div style='width:4px;'></div>",d.support.shrinkWrapBlocks=a.offsetWidth!==2),a.innerHTML="<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";var e=a.getElementsByTagName("td");d.support.reliableHiddenOffsets=e[0].offsetHeight===0,e[0].style.display="",e[1].style.display="none",d.support.reliableHiddenOffsets=d.support.reliableHiddenOffsets&&e[0].offsetHeight===0,a.innerHTML="",c.defaultView&&c.defaultView.getComputedStyle&&(a.style.width="1px",a.style.marginRight="0",d.support.reliableMarginRight=(parseInt(c.defaultView.getComputedStyle(a,null).marginRight,10)||0)===0),b.removeChild(a).style.display="none",a=e=null}});var n=function(a){var b=c.createElement("div");a="on"+a;if(!b.attachEvent)return!0;var d=a in b;d||(b.setAttribute(a,"return;"),d=typeof b[a]==="function");return d};d.support.submitBubbles=n("submit"),d.support.changeBubbles=n("change"),b=e=f=null}}();var g=/^(?:\{.*\}|\[.*\])$/;d.extend({cache:{},uuid:0,expando:"jQuery"+(d.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?d.cache[a[d.expando]]:a[d.expando];return!!a&&!i(a)},data:function(a,c,e,f){if(d.acceptData(a)){var g=d.expando,h=typeof c==="string",i,j=a.nodeType,k=j?d.cache:a,l=j?a[d.expando]:a[d.expando]&&d.expando;if((!l||f&&l&&!k[l][g])&&h&&e===b)return;l||(j?a[d.expando]=l=++d.uuid:l=d.expando),k[l]||(k[l]={},j||(k[l].toJSON=d.noop));if(typeof c==="object"||typeof c==="function")f?k[l][g]=d.extend(k[l][g],c):k[l]=d.extend(k[l],c);i=k[l],f&&(i[g]||(i[g]={}),i=i[g]),e!==b&&(i[c]=e);if(c==="events"&&!i[c])return i[g]&&i[g].events;return h?i[c]:i}},removeData:function(b,c,e){if(d.acceptData(b)){var f=d.expando,g=b.nodeType,h=g?d.cache:b,j=g?b[d.expando]:d.expando;if(!h[j])return;if(c){var k=e?h[j][f]:h[j];if(k){delete k[c];if(!i(k))return}}if(e){delete h[j][f];if(!i(h[j]))return}var l=h[j][f];d.support.deleteExpando||h!=a?delete h[j]:h[j]=null,l?(h[j]={},g||(h[j].toJSON=d.noop),h[j][f]=l):g&&(d.support.deleteExpando?delete b[d.expando]:b.removeAttribute?b.removeAttribute(d.expando):b[d.expando]=null)}},_data:function(a,b,c){return d.data(a,b,c,!0)},acceptData:function(a){if(a.nodeName){var b=d.noData[a.nodeName.toLowerCase()];if(b)return b!==!0&&a.getAttribute("classid")===b}return!0}}),d.fn.extend({data:function(a,c){var e=null;if(typeof a==="undefined"){if(this.length){e=d.data(this[0]);if(this[0].nodeType===1){var f=this[0].attributes,g;for(var i=0,j=f.length;i<j;i++)g=f[i].name,g.indexOf("data-")===0&&(g=g.substr(5),h(this[0],g,e[g]))}}return e}if(typeof a==="object")return this.each(function(){d.data(this,a)});var k=a.split(".");k[1]=k[1]?"."+k[1]:"";if(c===b){e=this.triggerHandler("getData"+k[1]+"!",[k[0]]),e===b&&this.length&&(e=d.data(this[0],a),e=h(this[0],a,e));return e===b&&k[1]?this.data(k[0]):e}return this.each(function(){var b=d(this),e=[k[0],c];b.triggerHandler("setData"+k[1]+"!",e),d.data(this,a,c),b.triggerHandler("changeData"+k[1]+"!",e)})},removeData:function(a){return this.each(function(){d.removeData(this,a)})}}),d.extend({queue:function(a,b,c){if(a){b=(b||"fx")+"queue";var e=d._data(a,b);if(!c)return e||[];!e||d.isArray(c)?e=d._data(a,b,d.makeArray(c)):e.push(c);return e}},dequeue:function(a,b){b=b||"fx";var c=d.queue(a,b),e=c.shift();e==="inprogress"&&(e=c.shift()),e&&(b==="fx"&&c.unshift("inprogress"),e.call(a,function(){d.dequeue(a,b)})),c.length||d.removeData(a,b+"queue",!0)}}),d.fn.extend({queue:function(a,c){typeof a!=="string"&&(c=a,a="fx");if(c===b)return d.queue(this[0],a);return this.each(function(b){var e=d.queue(this,a,c);a==="fx"&&e[0]!=="inprogress"&&d.dequeue(this,a)})},dequeue:function(a){return this.each(function(){d.dequeue(this,a)})},delay:function(a,b){a=d.fx?d.fx.speeds[a]||a:a,b=b||"fx";return this.queue(b,function(){var c=this;setTimeout(function(){d.dequeue(c,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var j=/[\n\t\r]/g,k=/\s+/,l=/\r/g,m=/^(?:href|src|style)$/,n=/^(?:button|input)$/i,o=/^(?:button|input|object|select|textarea)$/i,p=/^a(?:rea)?$/i,q=/^(?:radio|checkbox)$/i;d.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"},d.fn.extend({attr:function(a,b){return d.access(this,a,b,!0,d.attr)},removeAttr:function(a,b){return this.each(function(){d.attr(this,a,""),this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(d.isFunction(a))return this.each(function(b){var c=d(this);c.addClass(a.call(this,b,c.attr("class")))});if(a&&typeof a==="string"){var b=(a||"").split(k);for(var c=0,e=this.length;c<e;c++){var f=this[c];if(f.nodeType===1)if(f.className){var g=" "+f.className+" ",h=f.className;for(var i=0,j=b.length;i<j;i++)g.indexOf(" "+b[i]+" ")<0&&(h+=" "+b[i]);f.className=d.trim(h)}else f.className=a}}return this},removeClass:function(a){if(d.isFunction(a))return this.each(function(b){var c=d(this);c.removeClass(a.call(this,b,c.attr("class")))});if(a&&typeof a==="string"||a===b){var c=(a||"").split(k);for(var e=0,f=this.length;e<f;e++){var g=this[e];if(g.nodeType===1&&g.className)if(a){var h=(" "+g.className+" ").replace(j," ");for(var i=0,l=c.length;i<l;i++)h=h.replace(" "+c[i]+" "," ");g.className=d.trim(h)}else g.className=""}}return this},toggleClass:function(a,b){var c=typeof a,e=typeof b==="boolean";if(d.isFunction(a))return this.each(function(c){var e=d(this);e.toggleClass(a.call(this,c,e.attr("class"),b),b)});return this.each(function(){if(c==="string"){var f,g=0,h=d(this),i=b,j=a.split(k);while(f=j[g++])i=e?i:!h.hasClass(f),h[i?"addClass":"removeClass"](f)}else if(c==="undefined"||c==="boolean")this.className&&d._data(this,"__className__",this.className),this.className=this.className||a===!1?"":d._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ";for(var c=0,d=this.length;c<d;c++)if((" "+this[c].className+" ").replace(j," ").indexOf(b)>-1)return!0;return!1},val:function(a){if(!arguments.length){var c=this[0];if(c){if(d.nodeName(c,"option")){var e=c.attributes.value;return!e||e.specified?c.value:c.text}if(d.nodeName(c,"select")){var f=c.selectedIndex,g=[],h=c.options,i=c.type==="select-one";if(f<0)return null;for(var j=i?f:0,k=i?f+1:h.length;j<k;j++){var m=h[j];if(m.selected&&(d.support.optDisabled?!m.disabled:m.getAttribute("disabled")===null)&&(!m.parentNode.disabled||!d.nodeName(m.parentNode,"optgroup"))){a=d(m).val();if(i)return a;g.push(a)}}if(i&&!g.length&&h.length)return d(h[f]).val();return g}if(q.test(c.type)&&!d.support.checkOn)return c.getAttribute("value")===null?"on":c.value;return(c.value||"").replace(l,"")}return b}var n=d.isFunction(a);return this.each(function(b){var c=d(this),e=a;if(this.nodeType===1){n&&(e=a.call(this,b,c.val())),e==null?e="":typeof e==="number"?e+="":d.isArray(e)&&(e=d.map(e,function(a){return a==null?"":a+""}));if(d.isArray(e)&&q.test(this.type))this.checked=d.inArray(c.val(),e)>=0;else if(d.nodeName(this,"select")){var f=d.makeArray(e);d("option",this).each(function(){this.selected=d.inArray(d(this).val(),f)>=0}),f.length||(this.selectedIndex=-1)}else this.value=e}})}}),d.extend({attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,e,f){if(!a||a.nodeType===3||a.nodeType===8||a.nodeType===2)return b;if(f&&c in d.attrFn)return d(a)[c](e);var g=a.nodeType!==1||!d.isXMLDoc(a),h=e!==b;c=g&&d.props[c]||c;if(a.nodeType===1){var i=m.test(c);if(c==="selected"&&!d.support.optSelected){var j=a.parentNode;j&&(j.selectedIndex,j.parentNode&&j.parentNode.selectedIndex)}if((c in a||a[c]!==b)&&g&&!i){h&&(c==="type"&&n.test(a.nodeName)&&a.parentNode&&d.error("type property can't be changed"),e===null?a.nodeType===1&&a.removeAttribute(c):a[c]=e);if(d.nodeName(a,"form")&&a.getAttributeNode(c))return a.getAttributeNode(c).nodeValue;if(c==="tabIndex"){var k=a.getAttributeNode("tabIndex");return k&&k.specified?k.value:o.test(a.nodeName)||p.test(a.nodeName)&&a.href?0:b}return a[c]}if(!d.support.style&&g&&c==="style"){h&&(a.style.cssText=""+e);return a.style.cssText}h&&a.setAttribute(c,""+e);if(!a.attributes[c]&&(a.hasAttribute&&!a.hasAttribute(c)))return b;var l=!d.support.hrefNormalized&&g&&i?a.getAttribute(c,2):a.getAttribute(c);return l===null?b:l}h&&(a[c]=e);return a[c]}});var r=/\.(.*)$/,s=/^(?:textarea|input|select)$/i,t=/\./g,u=/ /g,v=/[^\w\s.|`]/g,w=function(a){return a.replace(v,"\\$&")};d.event={add:function(c,e,f,g){if(c.nodeType!==3&&c.nodeType!==8){try{d.isWindow(c)&&(c!==a&&!c.frameElement)&&(c=a)}catch(h){}if(f===!1)f=x;else if(!f)return;var i,j;f.handler&&(i=f,f=i.handler),f.guid||(f.guid=d.guid++);var k=d._data(c);if(!k)return;var l=k.events,m=k.handle;l||(k.events=l={}),m||(k.handle=m=function(a){return typeof d!=="undefined"&&d.event.triggered!==a.type?d.event.handle.apply(m.elem,arguments):b}),m.elem=c,e=e.split(" ");var n,o=0,p;while(n=e[o++]){j=i?d.extend({},i):{handler:f,data:g},n.indexOf(".")>-1?(p=n.split("."),n=p.shift(),j.namespace=p.slice(0).sort().join(".")):(p=[],j.namespace=""),j.type=n,j.guid||(j.guid=f.guid);var q=l[n],r=d.event.special[n]||{};if(!q){q=l[n]=[];if(!r.setup||r.setup.call(c,g,p,m)===!1)c.addEventListener?c.addEventListener(n,m,!1):c.attachEvent&&c.attachEvent("on"+n,m)}r.add&&(r.add.call(c,j),j.handler.guid||(j.handler.guid=f.guid)),q.push(j),d.event.global[n]=!0}c=null}},global:{},remove:function(a,c,e,f){if(a.nodeType!==3&&a.nodeType!==8){e===!1&&(e=x);var g,h,i,j,k=0,l,m,n,o,p,q,r,s=d.hasData(a)&&d._data(a),t=s&&s.events;if(!s||!t)return;c&&c.type&&(e=c.handler,c=c.type);if(!c||typeof c==="string"&&c.charAt(0)==="."){c=c||"";for(h in t)d.event.remove(a,h+c);return}c=c.split(" ");while(h=c[k++]){r=h,q=null,l=h.indexOf(".")<0,m=[],l||(m=h.split("."),h=m.shift(),n=new RegExp("(^|\\.)"+d.map(m.slice(0).sort(),w).join("\\.(?:.*\\.)?")+"(\\.|$)")),p=t[h];if(!p)continue;if(!e){for(j=0;j<p.length;j++){q=p[j];if(l||n.test(q.namespace))d.event.remove(a,r,q.handler,j),p.splice(j--,1)}continue}o=d.event.special[h]||{};for(j=f||0;j<p.length;j++){q=p[j];if(e.guid===q.guid){if(l||n.test(q.namespace))f==null&&p.splice(j--,1),o.remove&&o.remove.call(a,q);if(f!=null)break}}if(p.length===0||f!=null&&p.length===1)(!o.teardown||o.teardown.call(a,m)===!1)&&d.removeEvent(a,h,s.handle),g=null,delete t[h]}if(d.isEmptyObject(t)){var u=s.handle;u&&(u.elem=null),delete s.events,delete s.handle,d.isEmptyObject(s)&&d.removeData(a,b,!0)}}},trigger:function(a,c,e){var f=a.type||a,g=arguments[3];if(!g){a=typeof a==="object"?a[d.expando]?a:d.extend(d.Event(f),a):d.Event(f),f.indexOf("!")>=0&&(a.type=f=f.slice(0,-1),a.exclusive=!0),e||(a.stopPropagation(),d.event.global[f]&&d.each(d.cache,function(){var b=d.expando,e=this[b];e&&e.events&&e.events[f]&&d.event.trigger(a,c,e.handle.elem)}));if(!e||e.nodeType===3||e.nodeType===8)return b;a.result=b,a.target=e,c=d.makeArray(c),c.unshift(a)}a.currentTarget=e;var h=d._data(e,"handle");h&&h.apply(e,c);var i=e.parentNode||e.ownerDocument;try{e&&e.nodeName&&d.noData[e.nodeName.toLowerCase()]||e["on"+f]&&e["on"+f].apply(e,c)===!1&&(a.result=!1,a.preventDefault())}catch(j){}if(!a.isPropagationStopped()&&i)d.event.trigger(a,c,i,!0);else if(!a.isDefaultPrevented()){var k,l=a.target,m=f.replace(r,""),n=d.nodeName(l,"a")&&m==="click",o=d.event.special[m]||{};if((!o._default||o._default.call(e,a)===!1)&&!n&&!(l&&l.nodeName&&d.noData[l.nodeName.toLowerCase()])){try{l[m]&&(k=l["on"+m],k&&(l["on"+m]=null),d.event.triggered=a.type,l[m]())}catch(p){}k&&(l["on"+m]=k),d.event.triggered=b}}},handle:function(c){var e,f,g,h,i,j=[],k=d.makeArray(arguments);c=k[0]=d.event.fix(c||a.event),c.currentTarget=this,e=c.type.indexOf(".")<0&&!c.exclusive,e||(g=c.type.split("."),c.type=g.shift(),j=g.slice(0).sort(),h=new RegExp("(^|\\.)"+j.join("\\.(?:.*\\.)?")+"(\\.|$)")),c.namespace=c.namespace||j.join("."),i=d._data(this,"events"),f=(i||{})[c.type];if(i&&f){f=f.slice(0);for(var l=0,m=f.length;l<m;l++){var n=f[l];if(e||h.test(n.namespace)){c.handler=n.handler,c.data=n.data,c.handleObj=n;var o=n.handler.apply(this,k);o!==b&&(c.result=o,o===!1&&(c.preventDefault(),c.stopPropagation()));if(c.isImmediatePropagationStopped())break}}}return c.result},props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),fix:function(a){if(a[d.expando])return a;var e=a;a=d.Event(e);for(var f=this.props.length,g;f;)g=this.props[--f],a[g]=e[g];a.target||(a.target=a.srcElement||c),a.target.nodeType===3&&(a.target=a.target.parentNode),!a.relatedTarget&&a.fromElement&&(a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement);if(a.pageX==null&&a.clientX!=null){var h=c.documentElement,i=c.body;a.pageX=a.clientX+(h&&h.scrollLeft||i&&i.scrollLeft||0)-(h&&h.clientLeft||i&&i.clientLeft||0),a.pageY=a.clientY+(h&&h.scrollTop||i&&i.scrollTop||0)-(h&&h.clientTop||i&&i.clientTop||0)}a.which==null&&(a.charCode!=null||a.keyCode!=null)&&(a.which=a.charCode!=null?a.charCode:a.keyCode),!a.metaKey&&a.ctrlKey&&(a.metaKey=a.ctrlKey),!a.which&&a.button!==b&&(a.which=a.button&1?1:a.button&2?3:a.button&4?2:0);return a},guid:1e8,proxy:d.proxy,special:{ready:{setup:d.bindReady,teardown:d.noop},live:{add:function(a){d.event.add(this,H(a.origType,a.selector),d.extend({},a,{handler:G,guid:a.handler.guid}))},remove:function(a){d.event.remove(this,H(a.origType,a.selector),a)}},beforeunload:{setup:function(a,b,c){d.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}}},d.removeEvent=c.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){a.detachEvent&&a.detachEvent("on"+b,c)},d.Event=function(a){if(!this.preventDefault)return new d.Event(a);a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?y:x):this.type=a,this.timeStamp=d.now(),this[d.expando]=!0},d.Event.prototype={preventDefault:function(){this.isDefaultPrevented=y;var a=this.originalEvent;a&&(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){this.isPropagationStopped=y;var a=this.originalEvent;a&&(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=y,this.stopPropagation()},isDefaultPrevented:x,isPropagationStopped:x,isImmediatePropagationStopped:x};var z=function(a){var b=a.relatedTarget;try{if(b&&b!==c&&!b.parentNode)return;while(b&&b!==this)b=b.parentNode;b!==this&&(a.type=a.data,d.event.handle.apply(this,arguments))}catch(e){}},A=function(a){a.type=a.data,d.event.handle.apply(this,arguments)};d.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){d.event.special[a]={setup:function(c){d.event.add(this,b,c&&c.selector?A:z,a)},teardown:function(a){d.event.remove(this,b,a&&a.selector?A:z)}}}),d.support.submitBubbles||(d.event.special.submit={setup:function(a,b){if(this.nodeName&&this.nodeName.toLowerCase()!=="form")d.event.add(this,"click.specialSubmit",function(a){var b=a.target,c=b.type;(c==="submit"||c==="image")&&d(b).closest("form").length&&E("submit",this,arguments)}),d.event.add(this,"keypress.specialSubmit",function(a){var b=a.target,c=b.type;(c==="text"||c==="password")&&d(b).closest("form").length&&a.keyCode===13&&E("submit",this,arguments)});else return!1},teardown:function(a){d.event.remove(this,".specialSubmit")}});if(!d.support.changeBubbles){var B,C=function(a){var b=a.type,c=a.value;b==="radio"||b==="checkbox"?c=a.checked:b==="select-multiple"?c=a.selectedIndex>-1?d.map(a.options,function(a){return a.selected}).join("-"):"":a.nodeName.toLowerCase()==="select"&&(c=a.selectedIndex);return c},D=function D(a){var c=a.target,e,f;if(s.test(c.nodeName)&&!c.readOnly){e=d._data(c,"_change_data"),f=C(c),(a.type!=="focusout"||c.type!=="radio")&&d._data(c,"_change_data",f);if(e===b||f===e)return;if(e!=null||f)a.type="change",a.liveFired=b,d.event.trigger(a,arguments[1],c)}};d.event.special.change={filters:{focusout:D,beforedeactivate:D,click:function(a){var b=a.target,c=b.type;(c==="radio"||c==="checkbox"||b.nodeName.toLowerCase()==="select")&&D.call(this,a)},keydown:function(a){var b=a.target,c=b.type;(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(c==="checkbox"||c==="radio")||c==="select-multiple")&&D.call(this,a)},beforeactivate:function(a){var b=a.target;d._data(b,"_change_data",C(b))}},setup:function(a,b){if(this.type==="file")return!1;for(var c in B)d.event.add(this,c+".specialChange",B[c]);return s.test(this.nodeName)},teardown:function(a){d.event.remove(this,".specialChange");return s.test(this.nodeName)}},B=d.event.special.change.filters,B.focus=B.beforeactivate}c.addEventListener&&d.each({focus:"focusin",blur:"focusout"},function(a,b){function f(a){var c=d.event.fix(a);c.type=b,c.originalEvent={},d.event.trigger(c,null,c.target),c.isDefaultPrevented()&&a.preventDefault()}var e=0;d.event.special[b]={setup:function(){e++===0&&c.addEventListener(a,f,!0)},teardown:function(){--e===0&&c.removeEventListener(a,f,!0)}}}),d.each(["bind","one"],function(a,c){d.fn[c]=function(a,e,f){if(typeof a==="object"){for(var g in a)this[c](g,e,a[g],f);return this}if(d.isFunction(e)||e===!1)f=e,e=b;var h=c==="one"?d.proxy(f,function(a){d(this).unbind(a,h);return f.apply(this,arguments)}):f;if(a==="unload"&&c!=="one")this.one(a,e,f);else for(var i=0,j=this.length;i<j;i++)d.event.add(this[i],a,h,e);return this}}),d.fn.extend({unbind:function(a,b){if(typeof a!=="object"||a.preventDefault)for(var e=0,f=this.length;e<f;e++)d.event.remove(this[e],a,b);else for(var c in a)this.unbind(c,a[c]);return this},delegate:function(a,b,c,d){return this.live(b,c,d,a)},undelegate:function(a,b,c){return arguments.length===0?this.unbind("live"):this.die(b,null,c,a)},trigger:function(a,b){return this.each(function(){d.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){var c=d.Event(a);c.preventDefault(),c.stopPropagation(),d.event.trigger(c,b,this[0]);return c.result}},toggle:function(a){var b=arguments,c=1;while(c<b.length)d.proxy(a,b[c++]);return this.click(d.proxy(a,function(e){var f=(d._data(this,"lastToggle"+a.guid)||0)%c;d._data(this,"lastToggle"+a.guid,f+1),e.preventDefault();return b[f].apply(this,arguments)||!1}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var F={focus:"focusin",blur:"focusout",mouseenter:"mouseover",mouseleave:"mouseout"};d.each(["live","die"],function(a,c){d.fn[c]=function(a,e,f,g){var h,i=0,j,k,l,m=g||this.selector,n=g?this:d(this.context);if(typeof a==="object"&&!a.preventDefault){for(var o in a)n[c](o,e,a[o],m);return this}d.isFunction(e)&&(f=e,e=b),a=(a||"").split(" ");while((h=a[i++])!=null){j=r.exec(h),k="",j&&(k=j[0],h=h.replace(r,""));if(h==="hover"){a.push("mouseenter"+k,"mouseleave"+k);continue}l=h,h==="focus"||h==="blur"?(a.push(F[h]+k),h=h+k):h=(F[h]||h)+k;if(c==="live")for(var p=0,q=n.length;p<q;p++)d.event.add(n[p],"live."+H(h,m),{data:e,selector:m,handler:f,origType:h,origHandler:f,preType:l});else n.unbind("live."+H(h,m),f)}return this}}),d.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),function(a,b){d.fn[b]=function(a,c){c==null&&(c=a,a=null);return arguments.length>0?this.bind(b,a,c):this.trigger(b)},d.attrFn&&(d.attrFn[b]=!0)}),function(){function u(a,b,c,d,e,f){for(var g=0,h=d.length;g<h;g++){var i=d[g];if(i){var j=!1;i=i[a];while(i){if(i.sizcache===c){j=d[i.sizset];break}if(i.nodeType===1){f||(i.sizcache=c,i.sizset=g);if(typeof b!=="string"){if(i===b){j=!0;break}}else if(k.filter(b,[i]).length>0){j=i;break}}i=i[a]}d[g]=j}}}function t(a,b,c,d,e,f){for(var g=0,h=d.length;g<h;g++){var i=d[g];if(i){var j=!1;i=i[a];while(i){if(i.sizcache===c){j=d[i.sizset];break}i.nodeType===1&&!f&&(i.sizcache=c,i.sizset=g);if(i.nodeName.toLowerCase()===b){j=i;break}i=i[a]}d[g]=j}}}var a=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,e=0,f=Object.prototype.toString,g=!1,h=!0,i=/\\/g,j=/\W/;[0,0].sort(function(){h=!1;return 0});var k=function(b,d,e,g){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!=="string")return e;var i,j,n,o,q,r,s,t,u=!0,w=k.isXML(d),x=[],y=b;do{a.exec(""),i=a.exec(y);if(i){y=i[3],x.push(i[1]);if(i[2]){o=i[3];break}}}while(i);if(x.length>1&&m.exec(b))if(x.length===2&&l.relative[x[0]])j=v(x[0]+x[1],d);else{j=l.relative[x[0]]?[d]:k(x.shift(),d);while(x.length)b=x.shift(),l.relative[b]&&(b+=x.shift()),j=v(b,j)}else{!g&&x.length>1&&d.nodeType===9&&!w&&l.match.ID.test(x[0])&&!l.match.ID.test(x[x.length-1])&&(q=k.find(x.shift(),d,w),d=q.expr?k.filter(q.expr,q.set)[0]:q.set[0]);if(d){q=g?{expr:x.pop(),set:p(g)}:k.find(x.pop(),x.length===1&&(x[0]==="~"||x[0]==="+")&&d.parentNode?d.parentNode:d,w),j=q.expr?k.filter(q.expr,q.set):q.set,x.length>0?n=p(j):u=!1;while(x.length)r=x.pop(),s=r,l.relative[r]?s=x.pop():r="",s==null&&(s=d),l.relative[r](n,s,w)}else n=x=[]}n||(n=j),n||k.error(r||b);if(f.call(n)==="[object Array]")if(u)if(d&&d.nodeType===1)for(t=0;n[t]!=null;t++)n[t]&&(n[t]===!0||n[t].nodeType===1&&k.contains(d,n[t]))&&e.push(j[t]);else for(t=0;n[t]!=null;t++)n[t]&&n[t].nodeType===1&&e.push(j[t]);else e.push.apply(e,n);else p(n,e);o&&(k(o,h,e,g),k.uniqueSort(e));return e};k.uniqueSort=function(a){if(r){g=h,a.sort(r);if(g)for(var b=1;b<a.length;b++)a[b]===a[b-1]&&a.splice(b--,1)}return a},k.matches=function(a,b){return k(a,null,null,b)},k.matchesSelector=function(a,b){return k(b,null,null,[a]).length>0},k.find=function(a,b,c){var d;if(!a)return[];for(var e=0,f=l.order.length;e<f;e++){var g,h=l.order[e];if(g=l.leftMatch[h].exec(a)){var j=g[1];g.splice(1,1);if(j.substr(j.length-1)!=="\\"){g[1]=(g[1]||"").replace(i,""),d=l.find[h](g,b,c);if(d!=null){a=a.replace(l.match[h],"");break}}}}d||(d=typeof b.getElementsByTagName!=="undefined"?b.getElementsByTagName("*"):[]);return{set:d,expr:a}},k.filter=function(a,c,d,e){var f,g,h=a,i=[],j=c,m=c&&c[0]&&k.isXML(c[0]);while(a&&c.length){for(var n in l.filter)if((f=l.leftMatch[n].exec(a))!=null&&f[2]){var o,p,q=l.filter[n],r=f[1];g=!1,f.splice(1,1);if(r.substr(r.length-1)==="\\")continue;j===i&&(i=[]);if(l.preFilter[n]){f=l.preFilter[n](f,j,d,i,e,m);if(f){if(f===!0)continue}else g=o=!0}if(f)for(var s=0;(p=j[s])!=null;s++)if(p){o=q(p,f,s,j);var t=e^!!o;d&&o!=null?t?g=!0:j[s]=!1:t&&(i.push(p),g=!0)}if(o!==b){d||(j=i),a=a.replace(l.match[n],"");if(!g)return[];break}}if(a===h)if(g==null)k.error(a);else break;h=a}return j},k.error=function(a){throw"Syntax error, unrecognized expression: "+a};var l=k.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(a){return a.getAttribute("href")},type:function(a){return a.getAttribute("type")}},relative:{"+":function(a,b){var c=typeof b==="string",d=c&&!j.test(b),e=c&&!d;d&&(b=b.toLowerCase());for(var f=0,g=a.length,h;f<g;f++)if(h=a[f]){while((h=h.previousSibling)&&h.nodeType!==1){}a[f]=e||h&&h.nodeName.toLowerCase()===b?h||!1:h===b}e&&k.filter(b,a,!0)},">":function(a,b){var c,d=typeof b==="string",e=0,f=a.length;if(d&&!j.test(b)){b=b.toLowerCase();for(;e<f;e++){c=a[e];if(c){var g=c.parentNode;a[e]=g.nodeName.toLowerCase()===b?g:!1}}}else{for(;e<f;e++)c=a[e],c&&(a[e]=d?c.parentNode:c.parentNode===b);d&&k.filter(b,a,!0)}},"":function(a,b,c){var d,f=e++,g=u;typeof b==="string"&&!j.test(b)&&(b=b.toLowerCase(),d=b,g=t),g("parentNode",b,f,a,d,c)},"~":function(a,b,c){var d,f=e++,g=u;typeof b==="string"&&!j.test(b)&&(b=b.toLowerCase(),d=b,g=t),g("previousSibling",b,f,a,d,c)}},find:{ID:function(a,b,c){if(typeof b.getElementById!=="undefined"&&!c){var d=b.getElementById(a[1]);return d&&d.parentNode?[d]:[]}},NAME:function(a,b){if(typeof b.getElementsByName!=="undefined"){var c=[],d=b.getElementsByName(a[1]);for(var e=0,f=d.length;e<f;e++)d[e].getAttribute("name")===a[1]&&c.push(d[e]);return c.length===0?null:c}},TAG:function(a,b){if(typeof b.getElementsByTagName!=="undefined")return b.getElementsByTagName(a[1])}},preFilter:{CLASS:function(a,b,c,d,e,f){a=" "+a[1].replace(i,"")+" ";if(f)return a;for(var g=0,h;(h=b[g])!=null;g++)h&&(e^(h.className&&(" "+h.className+" ").replace(/[\t\n\r]/g," ").indexOf(a)>=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(i,"")},TAG:function(a,b){return a[1].replace(i,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||k.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&k.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(i,"");!f&&l.attrMap[g]&&(a[1]=l.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(i,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=k(b[3],null,null,c);else{var g=k.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(l.match.POS.test(b[0])||l.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!k(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return"text"===c&&(b===c||b===null)},radio:function(a){return"radio"===a.type},checkbox:function(a){return"checkbox"===a.type},file:function(a){return"file"===a.type},password:function(a){return"password"===a.type},submit:function(a){return"submit"===a.type},image:function(a){return"image"===a.type},reset:function(a){return"reset"===a.type},button:function(a){return"button"===a.type||a.nodeName.toLowerCase()==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return b<c[3]-0},gt:function(a,b,c){return b>c[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=l.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||k.getText([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h<i;h++)if(g[h]===a)return!1;return!0}k.error(e)},CHILD:function(a,b){var c=b[1],d=a;switch(c){case"only":case"first":while(d=d.previousSibling)if(d.nodeType===1)return!1;if(c==="first")return!0;d=a;case"last":while(d=d.nextSibling)if(d.nodeType===1)return!1;return!0;case"nth":var e=b[2],f=b[3];if(e===1&&f===0)return!0;var g=b[0],h=a.parentNode;if(h&&(h.sizcache!==g||!a.nodeIndex)){var i=0;for(d=h.firstChild;d;d=d.nextSibling)d.nodeType===1&&(d.nodeIndex=++i);h.sizcache=g}var j=a.nodeIndex-f;return e===0?j===0:j%e===0&&j/e>=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=l.attrHandle[c]?l.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=l.setFilters[e];if(f)return f(a,c,b,d)}}},m=l.match.POS,n=function(a,b){return"\\"+(b-0+1)};for(var o in l.match)l.match[o]=new RegExp(l.match[o].source+/(?![^\[]*\])(?![^\(]*\))/.source),l.leftMatch[o]=new RegExp(/(^(?:.|\r|\n)*?)/.source+l.match[o].source.replace(/\\(\d+)/g,n));var p=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(q){p=function(a,b){var c=0,d=b||[];if(f.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length==="number")for(var e=a.length;c<e;c++)d.push(a[c]);else for(;a[c];c++)d.push(a[c]);return d}}var r,s;c.documentElement.compareDocumentPosition?r=function(a,b){if(a===b){g=!0;return 0}if(!a.compareDocumentPosition||!b.compareDocumentPosition)return a.compareDocumentPosition?-1:1;return a.compareDocumentPosition(b)&4?-1:1}:(r=function(a,b){var c,d,e=[],f=[],h=a.parentNode,i=b.parentNode,j=h;if(a===b){g=!0;return 0}if(h===i)return s(a,b);if(!h)return-1;if(!i)return 1;while(j)e.unshift(j),j=j.parentNode;j=i;while(j)f.unshift(j),j=j.parentNode;c=e.length,d=f.length;for(var k=0;k<c&&k<d;k++)if(e[k]!==f[k])return s(e[k],f[k]);return k===c?s(a,f[k],-1):s(e[k],b,1)},s=function(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}),k.getText=function(a){var b="",c;for(var d=0;a[d];d++)c=a[d],c.nodeType===3||c.nodeType===4?b+=c.nodeValue:c.nodeType!==8&&(b+=k.getText(c.childNodes));return b},function(){var a=c.createElement("div"),d="script"+(new Date).getTime(),e=c.documentElement;a.innerHTML="<a name='"+d+"'/>",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(l.find.ID=function(a,c,d){if(typeof c.getElementById!=="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!=="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},l.filter.ID=function(a,b){var c=typeof a.getAttributeNode!=="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(l.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!=="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(l.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=k,b=c.createElement("div"),d="__sizzle__";b.innerHTML="<p class='TEST'></p>";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){k=function(b,e,f,g){e=e||c;if(!g&&!k.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return p(e.getElementsByTagName(b),f);if(h[2]&&l.find.CLASS&&e.getElementsByClassName)return p(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return p([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return p([],f);if(i.id===h[3])return p([i],f)}try{return p(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var m=e,n=e.getAttribute("id"),o=n||d,q=e.parentNode,r=/^\s*[+~]/.test(b);n?o=o.replace(/'/g,"\\$&"):e.setAttribute("id",o),r&&q&&(e=e.parentNode);try{if(!r||q)return p(e.querySelectorAll("[id='"+o+"'] "+b),f)}catch(s){}finally{n||m.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)k[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}k.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!k.isXML(a))try{if(e||!l.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return k(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="<div class='test e'></div><div class='test'></div>";if(a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;l.order.splice(1,0,"CLASS"),l.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!=="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?k.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?k.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:k.contains=function(){return!1},k.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var v=function(a,b){var c,d=[],e="",f=b.nodeType?[b]:b;while(c=l.match.PSEUDO.exec(a))e+=c[0],a=a.replace(l.match.PSEUDO,"");a=l.relative[a]?a+"*":a;for(var g=0,h=f.length;g<h;g++)k(a,f[g],d);return k.filter(e,d)};d.find=k,d.expr=k.selectors,d.expr[":"]=d.expr.filters,d.unique=k.uniqueSort,d.text=k.getText,d.isXMLDoc=k.isXML,d.contains=k.contains}();var I=/Until$/,J=/^(?:parents|prevUntil|prevAll)/,K=/,/,L=/^.[^:#\[\.,]*$/,M=Array.prototype.slice,N=d.expr.match.POS,O={children:!0,contents:!0,next:!0,prev:!0};d.fn.extend({find:function(a){var b=this.pushStack("","find",a),c=0;for(var e=0,f=this.length;e<f;e++){c=b.length,d.find(a,this[e],b);if(e>0)for(var g=c;g<b.length;g++)for(var h=0;h<c;h++)if(b[h]===b[g]){b.splice(g--,1);break}}return b},has:function(a){var b=d(a);return this.filter(function(){for(var a=0,c=b.length;a<c;a++)if(d.contains(this,b[a]))return!0})},not:function(a){return this.pushStack(Q(this,a,!1),"not",a)},filter:function(a){return this.pushStack(Q(this,a,!0),"filter",a)},is:function(a){return!!a&&d.filter(a,this).length>0},closest:function(a,b){var c=[],e,f,g=this[0];if(d.isArray(a)){var h,i,j={},k=1;if(g&&a.length){for(e=0,f=a.length;e<f;e++)i=a[e],j[i]||(j[i]=d.expr.match.POS.test(i)?d(i,b||this.context):i);while(g&&g.ownerDocument&&g!==b){for(i in j)h=j[i],(h.jquery?h.index(g)>-1:d(g).is(h))&&c.push({selector:i,elem:g,level:k});g=g.parentNode,k++}}return c}var l=N.test(a)?d(a,b||this.context):null;for(e=0,f=this.length;e<f;e++){g=this[e];while(g){if(l?l.index(g)>-1:d.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b)break}}c=c.length>1?d.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a||typeof a==="string")return d.inArray(this[0],a?d(a):this.parent().children());return d.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a==="string"?d(a,b):d.makeArray(a),e=d.merge(this.get(),c);return this.pushStack(P(c[0])||P(e[0])?e:d.unique(e))},andSelf:function(){return this.add(this.prevObject)}}),d.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return d.dir(a,"parentNode")},parentsUntil:function(a,b,c){return d.dir(a,"parentNode",c)},next:function(a){return d.nth(a,2,"nextSibling")},prev:function(a){return d.nth(a,2,"previousSibling")},nextAll:function(a){return d.dir(a,"nextSibling")},prevAll:function(a){return d.dir(a,"previousSibling")},nextUntil:function(a,b,c){return d.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return d.dir(a,"previousSibling",c)},siblings:function(a){return d.sibling(a.parentNode.firstChild,a)},children:function(a){return d.sibling(a.firstChild)},contents:function(a){return d.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:d.makeArray(a.childNodes)}},function(a,b){d.fn[a]=function(c,e){var f=d.map(this,b,c),g=M.call(arguments);I.test(a)||(e=c),e&&typeof e==="string"&&(f=d.filter(e,f)),f=this.length>1&&!O[a]?d.unique(f):f,(this.length>1||K.test(e))&&J.test(a)&&(f=f.reverse());return this.pushStack(f,a,g.join(","))}}),d.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?d.find.matchesSelector(b[0],a)?[b[0]]:[]:d.find.matches(a,b)},dir:function(a,c,e){var f=[],g=a[c];while(g&&g.nodeType!==9&&(e===b||g.nodeType!==1||!d(g).is(e)))g.nodeType===1&&f.push(g),g=g[c];return f},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var R=/ jQuery\d+="(?:\d+|null)"/g,S=/^\s+/,T=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,U=/<([\w:]+)/,V=/<tbody/i,W=/<|&#?\w+;/,X=/<(?:script|object|embed|option|style)/i,Y=/checked\s*(?:[^=]|=\s*.checked.)/i,Z={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};Z.optgroup=Z.option,Z.tbody=Z.tfoot=Z.colgroup=Z.caption=Z.thead,Z.th=Z.td,d.support.htmlSerialize||(Z._default=[1,"div<div>","</div>"]),d.fn.extend({text:function(a){if(d.isFunction(a))return this.each(function(b){var c=d(this);c.text(a.call(this,b,c.text()))});if(typeof a!=="object"&&a!==b)return this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a));return d.text(this)},wrapAll:function(a){if(d.isFunction(a))return this.each(function(b){d(this).wrapAll(a.call(this,b))});if(this[0]){var b=d(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(d.isFunction(a))return this.each(function(b){d(this).wrapInner(a.call(this,b))});return this.each(function(){var b=d(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){d(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){d.nodeName(this,"body")||d(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=d(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,d(arguments[0]).toArray());return a}},remove:function(a,b){for(var c=0,e;(e=this[c])!=null;c++)if(!a||d.filter(a,[e]).length)!b&&e.nodeType===1&&(d.cleanData(e.getElementsByTagName("*")),d.cleanData([e])),e.parentNode&&e.parentNode.removeChild(e);return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&d.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return d.clone(this,a,b)})},html:function(a){if(a===b)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(R,""):null;if(typeof a!=="string"||X.test(a)||!d.support.leadingWhitespace&&S.test(a)||Z[(U.exec(a)||["",""])[1].toLowerCase()])d.isFunction(a)?this.each(function(b){var c=d(this);c.html(a.call(this,b,c.html()))}):this.empty().append(a);else{a=a.replace(T,"<$1></$2>");try{for(var c=0,e=this.length;c<e;c++)this[c].nodeType===1&&(d.cleanData(this[c].getElementsByTagName("*")),this[c].innerHTML=a)}catch(f){this.empty().append(a)}}return this},replaceWith:function(a){if(this[0]&&this[0].parentNode){if(d.isFunction(a))return this.each(function(b){var c=d(this),e=c.html();c.replaceWith(a.call(this,b,e))});typeof a!=="string"&&(a=d(a).detach());return this.each(function(){var b=this.nextSibling,c=this.parentNode;d(this).remove(),b?d(b).before(a):d(c).append(a)})}return this.length?this.pushStack(d(d.isFunction(a)?a():a),"replaceWith",a):this},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,e){var f,g,h,i,j=a[0],k=[];if(!d.support.checkClone&&arguments.length===3&&typeof j==="string"&&Y.test(j))return this.each(function(){d(this).domManip(a,c,e,!0)});if(d.isFunction(j))return this.each(function(f){var g=d(this);a[0]=j.call(this,f,c?g.html():b),g.domManip(a,c,e)});if(this[0]){i=j&&j.parentNode,d.support.parentNode&&i&&i.nodeType===11&&i.childNodes.length===this.length?f={fragment:i}:f=d.buildFragment(a,this,k),h=f.fragment,h.childNodes.length===1?g=h=h.firstChild:g=h.firstChild;if(g){c=c&&d.nodeName(g,"tr");for(var l=0,m=this.length,n=m-1;l<m;l++)e.call(c?$(this[l],g):this[l],f.cacheable||m>1&&l<n?d.clone(h,!0,!0):h)}k.length&&d.each(k,bc)}return this}}),d.buildFragment=function(a,b,e){var f,g,h,i=b&&b[0]?b[0].ownerDocument||b[0]:c;a.length===1&&typeof a[0]==="string"&&a[0].length<512&&i===c&&a[0].charAt(0)==="<"&&!X.test(a[0])&&(d.support.checkClone||!Y.test(a[0]))&&(g=!0,h=d.fragments[a[0]],h&&(h!==1&&(f=h))),f||(f=i.createDocumentFragment(),d.clean(a,i,f,e)),g&&(d.fragments[a[0]]=h?f:1);return{fragment:f,cacheable:g}},d.fragments={},d.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){d.fn[a]=function(c){var e=[],f=d(c),g=this.length===1&&this[0].parentNode;if(g&&g.nodeType===11&&g.childNodes.length===1&&f.length===1){f[b](this[0]);return this}for(var h=0,i=f.length;h<i;h++){var j=(h>0?this.clone(!0):this).get();d(f[h])[b](j),e=e.concat(j)}return this.pushStack(e,a,f.selector)}}),d.extend({clone:function(a,b,c){var e=a.cloneNode(!0),f,g,h;if((!d.support.noCloneEvent||!d.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!d.isXMLDoc(a)){ba(a,e),f=bb(a),g=bb(e);for(h=0;f[h];++h)ba(f[h],g[h])}if(b){_(a,e);if(c){f=bb(a),g=bb(e);for(h=0;f[h];++h)_(f[h],g[h])}}return e},clean:function(a,b,e,f){b=b||c,typeof b.createElement==="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);var g=[];for(var h=0,i;(i=a[h])!=null;h++){typeof i==="number"&&(i+="");if(!i)continue;if(typeof i!=="string"||W.test(i)){if(typeof i==="string"){i=i.replace(T,"<$1></$2>");var j=(U.exec(i)||["",""])[1].toLowerCase(),k=Z[j]||Z._default,l=k[0],m=b.createElement("div");m.innerHTML=k[1]+i+k[2];while(l--)m=m.lastChild;if(!d.support.tbody){var n=V.test(i),o=j==="table"&&!n?m.firstChild&&m.firstChild.childNodes:k[1]==="<table>"&&!n?m.childNodes:[];for(var p=o.length-1;p>=0;--p)d.nodeName(o[p],"tbody")&&!o[p].childNodes.length&&o[p].parentNode.removeChild(o[p])}!d.support.leadingWhitespace&&S.test(i)&&m.insertBefore(b.createTextNode(S.exec(i)[0]),m.firstChild),i=m.childNodes}}else i=b.createTextNode(i);i.nodeType?g.push(i):g=d.merge(g,i)}if(e)for(h=0;g[h];h++)!f||!d.nodeName(g[h],"script")||g[h].type&&g[h].type.toLowerCase()!=="text/javascript"?(g[h].nodeType===1&&g.splice.apply(g,[h+1,0].concat(d.makeArray(g[h].getElementsByTagName("script")))),e.appendChild(g[h])):f.push(g[h].parentNode?g[h].parentNode.removeChild(g[h]):g[h]);return g},cleanData:function(a){var b,c,e=d.cache,f=d.expando,g=d.event.special,h=d.support.deleteExpando;for(var i=0,j;(j=a[i])!=null;i++){if(j.nodeName&&d.noData[j.nodeName.toLowerCase()])continue;c=j[d.expando];if(c){b=e[c]&&e[c][f];if(b&&b.events){for(var k in b.events)g[k]?d.event.remove(j,k):d.removeEvent(j,k,b.handle);b.handle&&(b.handle.elem=null)}h?delete j[d.expando]:j.removeAttribute&&j.removeAttribute(d.expando),delete e[c]}}}});var bd=/alpha\([^)]*\)/i,be=/opacity=([^)]*)/,bf=/-([a-z])/ig,bg=/([A-Z]|^ms)/g,bh=/^-?\d+(?:px)?$/i,bi=/^-?\d/,bj={position:"absolute",visibility:"hidden",display:"block"},bk=["Left","Right"],bl=["Top","Bottom"],bm,bn,bo,bp=function(a,b){return b.toUpperCase()};d.fn.css=function(a,c){if(arguments.length===2&&c===b)return this;return d.access(this,a,c,!0,function(a,c,e){return e!==b?d.style(a,c,e):d.css(a,c)})},d.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bm(a,"opacity","opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{zIndex:!0,fontWeight:!0,opacity:!0,zoom:!0,lineHeight:!0},cssProps:{"float":d.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,e,f){if(a&&a.nodeType!==3&&a.nodeType!==8&&a.style){var g,h=d.camelCase(c),i=a.style,j=d.cssHooks[h];c=d.cssProps[h]||h;if(e===b){if(j&&"get"in j&&(g=j.get(a,!1,f))!==b)return g;return i[c]}if(typeof e==="number"&&isNaN(e)||e==null)return;typeof e==="number"&&!d.cssNumber[h]&&(e+="px");if(!j||!("set"in j)||(e=j.set(a,e))!==b)try{i[c]=e}catch(k){}}},css:function(a,c,e){var f,g=d.camelCase(c),h=d.cssHooks[g];c=d.cssProps[g]||g;if(h&&"get"in h&&(f=h.get(a,!0,e))!==b)return f;if(bm)return bm(a,c,g)},swap:function(a,b,c){var d={};for(var e in b)d[e]=a.style[e],a.style[e]=b[e];c.call(a);for(e in b)a.style[e]=d[e]},camelCase:function(a){return a.replace(bf,bp)}}),d.curCSS=d.css,d.each(["height","width"],function(a,b){d.cssHooks[b]={get:function(a,c,e){var f;if(c){a.offsetWidth!==0?f=bq(a,b,e):d.swap(a,bj,function(){f=bq(a,b,e)});if(f<=0){f=bm(a,b,b),f==="0px"&&bo&&(f=bo(a,b,b));if(f!=null)return f===""||f==="auto"?"0px":f}if(f<0||f==null){f=a.style[b];return f===""||f==="auto"?"0px":f}return typeof f==="string"?f:f+"px"}},set:function(a,b){if(!bh.test(b))return b;b=parseFloat(b);if(b>=0)return b+"px"}}}),d.support.opacity||(d.cssHooks.opacity={get:function(a,b){return be.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style;c.zoom=1;var e=d.isNaN(b)?"":"alpha(opacity="+b*100+")",f=c.filter||"";c.filter=bd.test(f)?f.replace(bd,e):c.filter+" "+e}}),d(function(){d.support.reliableMarginRight||(d.cssHooks.marginRight={get:function(a,b){var c;d.swap(a,{display:"inline-block"},function(){b?c=bm(a,"margin-right","marginRight"):c=a.style.marginRight});return c}})}),c.defaultView&&c.defaultView.getComputedStyle&&(bn=function(a,c,e){var f,g,h;e=e.replace(bg,"-$1").toLowerCase();if(!(g=a.ownerDocument.defaultView))return b;if(h=g.getComputedStyle(a,null))f=h.getPropertyValue(e),f===""&&!d.contains(a.ownerDocument.documentElement,a)&&(f=d.style(a,e));return f}),c.documentElement.currentStyle&&(bo=function(a,b){var c,d=a.currentStyle&&a.currentStyle[b],e=a.runtimeStyle&&a.runtimeStyle[b],f=a.style;!bh.test(d)&&bi.test(d)&&(c=f.left,e&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":d||0,d=f.pixelLeft+"px",f.left=c,e&&(a.runtimeStyle.left=e));return d===""?"auto":d}),bm=bn||bo,d.expr&&d.expr.filters&&(d.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!d.support.reliableHiddenOffsets&&(a.style.display||d.css(a,"display"))==="none"},d.expr.filters.visible=function(a){return!d.expr.filters.hidden(a)});var br=/%20/g,bs=/\[\]$/,bt=/\r?\n/g,bu=/#.*$/,bv=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bw=/^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bx=/^(?:about|app|app\-storage|.+\-extension|file|widget):$/,by=/^(?:GET|HEAD)$/,bz=/^\/\//,bA=/\?/,bB=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,bC=/^(?:select|textarea)/i,bD=/\s+/,bE=/([?&])_=[^&]*/,bF=/(^|\-)([a-z])/g,bG=function(a,b,c){return b+c.toUpperCase()},bH=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bI=d.fn.load,bJ={},bK={},bL,bM;try{bL=c.location.href}catch(bN){bL=c.createElement("a"),bL.href="",bL=bL.href}bM=bH.exec(bL.toLowerCase())||[],d.fn.extend({load:function(a,c,e){if(typeof a!=="string"&&bI)return bI.apply(this,arguments);if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var g=a.slice(f,a.length);a=a.slice(0,f)}var h="GET";c&&(d.isFunction(c)?(e=c,c=b):typeof c==="object"&&(c=d.param(c,d.ajaxSettings.traditional),h="POST"));var i=this;d.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?d("<div>").append(c.replace(bB,"")).find(g):c)),e&&i.each(e,[c,b,a])}});return this},serialize:function(){return d.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?d.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bC.test(this.nodeName)||bw.test(this.type))}).map(function(a,b){var c=d(this).val();return c==null?null:d.isArray(c)?d.map(c,function(a,c){return{name:b.name,value:a.replace(bt,"\r\n")}}):{name:b.name,value:c.replace(bt,"\r\n")}}).get()}}),d.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){d.fn[b]=function(a){return this.bind(b,a)}}),d.each(["get","post"],function(a,c){d[c]=function(a,e,f,g){d.isFunction(e)&&(g=g||f,f=e,e=b);return d.ajax({type:c,url:a,data:e,success:f,dataType:g})}}),d.extend({getScript:function(a,c){return d.get(a,b,c,"script")},getJSON:function(a,b,c){return d.get(a,b,c,"json")},ajaxSetup:function(a,b){b?d.extend(!0,a,d.ajaxSettings,b):(b=a,a=d.extend(!0,d.ajaxSettings,b));for(var c in {context:1,url:1})c in b?a[c]=b[c]:c in d.ajaxSettings&&(a[c]=d.ajaxSettings[c]);return a},ajaxSettings:{url:bL,isLocal:bx.test(bM[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":"*/*"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":d.parseJSON,"text xml":d.parseXML}},ajaxPrefilter:bO(bJ),ajaxTransport:bO(bK),ajax:function(a,c){function v(a,c,l,n){if(r!==2){r=2,p&&clearTimeout(p),o=b,m=n||"",u.readyState=a?4:0;var q,t,v,w=l?bR(e,u,l):b,x,y;if(a>=200&&a<300||a===304){if(e.ifModified){if(x=u.getResponseHeader("Last-Modified"))d.lastModified[k]=x;if(y=u.getResponseHeader("Etag"))d.etag[k]=y}if(a===304)c="notmodified",q=!0;else try{t=bS(e,w),c="success",q=!0}catch(z){c="parsererror",v=z}}else{v=c;if(!c||a)c="error",a<0&&(a=0)}u.status=a,u.statusText=c,q?h.resolveWith(f,[t,c,u]):h.rejectWith(f,[u,c,v]),u.statusCode(j),j=b,s&&g.trigger("ajax"+(q?"Success":"Error"),[u,e,q?t:v]),i.resolveWith(f,[u,c]),s&&(g.trigger("ajaxComplete",[u,e]),--d.active||d.event.trigger("ajaxStop"))}}typeof a==="object"&&(c=a,a=b),c=c||{};var e=d.ajaxSetup({},c),f=e.context||e,g=f!==e&&(f.nodeType||f instanceof d)?d(f):d.event,h=d.Deferred(),i=d._Deferred(),j=e.statusCode||{},k,l={},m,n,o,p,q,r=0,s,t,u={readyState:0,setRequestHeader:function(a,b){r||(l[a.toLowerCase().replace(bF,bG)]=b);return this},getAllResponseHeaders:function(){return r===2?m:null},getResponseHeader:function(a){var c;if(r===2){if(!n){n={};while(c=bv.exec(m))n[c[1].toLowerCase()]=c[2]}c=n[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){r||(e.mimeType=a);return this},abort:function(a){a=a||"abort",o&&o.abort(a),v(0,a);return this}};h.promise(u),u.success=u.done,u.error=u.fail,u.complete=i.done,u.statusCode=function(a){if(a){var b;if(r<2)for(b in a)j[b]=[j[b],a[b]];else b=a[u.status],u.then(b,b)}return this},e.url=((a||e.url)+"").replace(bu,"").replace(bz,bM[1]+"//"),e.dataTypes=d.trim(e.dataType||"*").toLowerCase().split(bD),e.crossDomain==null&&(q=bH.exec(e.url.toLowerCase()),e.crossDomain=q&&(q[1]!=bM[1]||q[2]!=bM[2]||(q[3]||(q[1]==="http:"?80:443))!=(bM[3]||(bM[1]==="http:"?80:443)))),e.data&&e.processData&&typeof e.data!=="string"&&(e.data=d.param(e.data,e.traditional)),bP(bJ,e,c,u);if(r===2)return!1;s=e.global,e.type=e.type.toUpperCase(),e.hasContent=!by.test(e.type),s&&d.active++===0&&d.event.trigger("ajaxStart");if(!e.hasContent){e.data&&(e.url+=(bA.test(e.url)?"&":"?")+e.data),k=e.url;if(e.cache===!1){var w=d.now(),x=e.url.replace(bE,"$1_="+w);e.url=x+(x===e.url?(bA.test(e.url)?"&":"?")+"_="+w:"")}}if(e.data&&e.hasContent&&e.contentType!==!1||c.contentType)l["Content-Type"]=e.contentType;e.ifModified&&(k=k||e.url,d.lastModified[k]&&(l["If-Modified-Since"]=d.lastModified[k]),d.etag[k]&&(l["If-None-Match"]=d.etag[k])),l.Accept=e.dataTypes[0]&&e.accepts[e.dataTypes[0]]?e.accepts[e.dataTypes[0]]+(e.dataTypes[0]!=="*"?", */*; q=0.01":""):e.accepts["*"];for(t in e.headers)u.setRequestHeader(t,e.headers[t]);if(e.beforeSend&&(e.beforeSend.call(f,u,e)===!1||r===2)){u.abort();return!1}for(t in {success:1,error:1,complete:1})u[t](e[t]);o=bP(bK,e,c,u);if(o){u.readyState=1,s&&g.trigger("ajaxSend",[u,e]),e.async&&e.timeout>0&&(p=setTimeout(function(){u.abort("timeout")},e.timeout));try{r=1,o.send(l,v)}catch(y){status<2?v(-1,y):d.error(y)}}else v(-1,"No Transport");return u},param:function(a,c){var e=[],f=function(a,b){b=d.isFunction(b)?b():b,e[e.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=d.ajaxSettings.traditional);if(d.isArray(a)||a.jquery&&!d.isPlainObject(a))d.each(a,function(){f(this.name,this.value)});else for(var g in a)bQ(g,a[g],c,f);return e.join("&").replace(br,"+")}}),d.extend({active:0,lastModified:{},etag:{}});var bT=d.now(),bU=/(\=)\?(&|$)|\?\?/i;d.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return d.expando+"_"+bT++}}),d.ajaxPrefilter("json jsonp",function(b,c,e){var f=typeof b.data==="string";if(b.dataTypes[0]==="jsonp"||c.jsonpCallback||c.jsonp!=null||b.jsonp!==!1&&(bU.test(b.url)||f&&bU.test(b.data))){var g,h=b.jsonpCallback=d.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2",m=function(){a[h]=i,g&&d.isFunction(i)&&a[h](g[0])};b.jsonp!==!1&&(j=j.replace(bU,l),b.url===j&&(f&&(k=k.replace(bU,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},e.then(m,m),b.converters["script json"]=function(){g||d.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),d.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){d.globalEval(a);return a}}}),d.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),d.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var bV=d.now(),bW,bX;d.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&bZ()||b$()}:bZ,bX=d.ajaxSettings.xhr(),d.support.ajax=!!bX,d.support.cors=bX&&"withCredentials"in bX,bX=b,d.support.ajax&&d.ajaxTransport(function(a){if(!a.crossDomain||d.support.cors){var c;return{send:function(e,f){var g=a.xhr(),h,i;a.username?g.open(a.type,a.url,a.async,a.username,a.password):g.open(a.type,a.url,a.async);if(a.xhrFields)for(i in a.xhrFields)g[i]=a.xhrFields[i];a.mimeType&&g.overrideMimeType&&g.overrideMimeType(a.mimeType),!a.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(i in e)g.setRequestHeader(i,e[i])}catch(j){}g.send(a.hasContent&&a.data||null),c=function(e,i){var j,k,l,m,n;try{if(c&&(i||g.readyState===4)){c=b,h&&(g.onreadystatechange=d.noop,delete bW[h]);if(i)g.readyState!==4&&g.abort();else{j=g.status,l=g.getAllResponseHeaders(),m={},n=g.responseXML,n&&n.documentElement&&(m.xml=n),m.text=g.responseText;try{k=g.statusText}catch(o){k=""}j||!a.isLocal||a.crossDomain?j===1223&&(j=204):j=m.text?200:404}}}catch(p){i||f(-1,p)}m&&f(j,k,m,l)},a.async&&g.readyState!==4?(bW||(bW={},bY()),h=bV++,g.onreadystatechange=bW[h]=c):c()},abort:function(){c&&c(0,1)}}}});var b_={},ca=/^(?:toggle|show|hide)$/,cb=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cc,cd=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];d.fn.extend({show:function(a,b,c){var e,f;if(a||a===0)return this.animate(ce("show",3),a,b,c);for(var g=0,h=this.length;g<h;g++)e=this[g],f=e.style.display,!d._data(e,"olddisplay")&&f==="none"&&(f=e.style.display=""),f===""&&d.css(e,"display")==="none"&&d._data(e,"olddisplay",cf(e.nodeName));for(g=0;g<h;g++){e=this[g],f=e.style.display;if(f===""||f==="none")e.style.display=d._data(e,"olddisplay")||""}return this},hide:function(a,b,c){if(a||a===0)return this.animate(ce("hide",3),a,b,c);for(var e=0,f=this.length;e<f;e++){var g=d.css(this[e],"display");g!=="none"&&!d._data(this[e],"olddisplay")&&d._data(this[e],"olddisplay",g)}for(e=0;e<f;e++)this[e].style.display="none";return this},_toggle:d.fn.toggle,toggle:function(a,b,c){var e=typeof a==="boolean";d.isFunction(a)&&d.isFunction(b)?this._toggle.apply(this,arguments):a==null||e?this.each(function(){var b=e?a:d(this).is(":hidden");d(this)[b?"show":"hide"]()}):this.animate(ce("toggle",3),a,b,c);return this},fadeTo:function(a,b,c,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,e){var f=d.speed(b,c,e);if(d.isEmptyObject(a))return this.each(f.complete);return this[f.queue===!1?"each":"queue"](function(){var b=d.extend({},f),c,e=this.nodeType===1,g=e&&d(this).is(":hidden"),h=this;for(c in a){var i=d.camelCase(c);c!==i&&(a[i]=a[c],delete a[c],c=i);if(a[c]==="hide"&&g||a[c]==="show"&&!g)return b.complete.call(this);if(e&&(c==="height"||c==="width")){b.overflow=[this.style.overflow,this.style.overflowX,this.style.overflowY];if(d.css(this,"display")==="inline"&&d.css(this,"float")==="none")if(d.support.inlineBlockNeedsLayout){var j=cf(this.nodeName);j==="inline"?this.style.display="inline-block":(this.style.display="inline",this.style.zoom=1)}else this.style.display="inline-block"}d.isArray(a[c])&&((b.specialEasing=b.specialEasing||{})[c]=a[c][1],a[c]=a[c][0])}b.overflow!=null&&(this.style.overflow="hidden"),b.curAnim=d.extend({},a),d.each(a,function(c,e){var f=new d.fx(h,b,c);if(ca.test(e))f[e==="toggle"?g?"show":"hide":e](a);else{var i=cb.exec(e),j=f.cur();if(i){var k=parseFloat(i[2]),l=i[3]||(d.cssNumber[c]?"":"px");l!=="px"&&(d.style(h,c,(k||1)+l),j=(k||1)/f.cur()*j,d.style(h,c,j+l)),i[1]&&(k=(i[1]==="-="?-1:1)*k+j),f.custom(j,k,l)}else f.custom(j,e,"")}});return!0})},stop:function(a,b){var c=d.timers;a&&this.queue([]),this.each(function(){for(var a=c.length-1;a>=0;a--)c[a].elem===this&&(b&&c[a](!0),c.splice(a,1))}),b||this.dequeue();return this}}),d.each({slideDown:ce("show",1),slideUp:ce("hide",1),slideToggle:ce("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){d.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),d.extend({speed:function(a,b,c){var e=a&&typeof a==="object"?d.extend({},a):{complete:c||!c&&b||d.isFunction(a)&&a,duration:a,easing:c&&b||b&&!d.isFunction(b)&&b};e.duration=d.fx.off?0:typeof e.duration==="number"?e.duration:e.duration in d.fx.speeds?d.fx.speeds[e.duration]:d.fx.speeds._default,e.old=e.complete,e.complete=function(){e.queue!==!1&&d(this).dequeue(),d.isFunction(e.old)&&e.old.call(this)};return e},easing:{linear:function(a,b,c,d){return c+d*a},swing:function(a,b,c,d){return(-Math.cos(a*Math.PI)/2+.5)*d+c}},timers:[],fx:function(a,b,c){this.options=b,this.elem=a,this.prop=c,b.orig||(b.orig={})}}),d.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this),(d.fx.step[this.prop]||d.fx.step._default)(this)},cur:function(){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];var a,b=d.css(this.elem,this.prop);return isNaN(a=parseFloat(b))?!b||b==="auto"?0:b:a},custom:function(a,b,c){function g(a){return e.step(a)}var e=this,f=d.fx;this.startTime=d.now(),this.start=a,this.end=b,this.unit=c||this.unit||(d.cssNumber[this.prop]?"":"px"),this.now=this.start,this.pos=this.state=0,g.elem=this.elem,g()&&d.timers.push(g)&&!cc&&(cc=setInterval(f.tick,f.interval))},show:function(){this.options.orig[this.prop]=d.style(this.elem,this.prop),this.options.show=!0,this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur()),d(this.elem).show()},hide:function(){this.options.orig[this.prop]=d.style(this.elem,this.prop),this.options.hide=!0,this.custom(this.cur(),0)},step:function(a){var b=d.now(),c=!0;if(a||b>=this.options.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),this.options.curAnim[this.prop]=!0;for(var e in this.options.curAnim)this.options.curAnim[e]!==!0&&(c=!1);if(c){if(this.options.overflow!=null&&!d.support.shrinkWrapBlocks){var f=this.elem,g=this.options;d.each(["","X","Y"],function(a,b){f.style["overflow"+b]=g.overflow[a]})}this.options.hide&&d(this.elem).hide();if(this.options.hide||this.options.show)for(var h in this.options.curAnim)d.style(this.elem,h,this.options.orig[h]);this.options.complete.call(this.elem)}return!1}var i=b-this.startTime;this.state=i/this.options.duration;var j=this.options.specialEasing&&this.options.specialEasing[this.prop],k=this.options.easing||(d.easing.swing?"swing":"linear");this.pos=d.easing[j||k](this.state,i,0,1,this.options.duration),this.now=this.start+(this.end-this.start)*this.pos,this.update();return!0}},d.extend(d.fx,{tick:function(){var a=d.timers;for(var b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||d.fx.stop()},interval:13,stop:function(){clearInterval(cc),cc=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){d.style(a.elem,"opacity",a.now)},_default:function(a){a.elem.style&&a.elem.style[a.prop]!=null?a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit:a.elem[a.prop]=a.now}}}),d.expr&&d.expr.filters&&(d.expr.filters.animated=function(a){return d.grep(d.timers,function(b){return a===b.elem}).length});var cg=/^t(?:able|d|h)$/i,ch=/^(?:body|html)$/i;"getBoundingClientRect"in c.documentElement?d.fn.offset=function(a){var b=this[0],c;if(a)return this.each(function(b){d.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return d.offset.bodyOffset(b);try{c=b.getBoundingClientRect()}catch(e){}var f=b.ownerDocument,g=f.documentElement;if(!c||!d.contains(g,b))return c?{top:c.top,left:c.left}:{top:0,left:0};var h=f.body,i=ci(f),j=g.clientTop||h.clientTop||0,k=g.clientLeft||h.clientLeft||0,l=i.pageYOffset||d.support.boxModel&&g.scrollTop||h.scrollTop,m=i.pageXOffset||d.support.boxModel&&g.scrollLeft||h.scrollLeft,n=c.top+l-j,o=c.left+m-k;return{top:n,left:o}}:d.fn.offset=function(a){var b=this[0];if(a)return this.each(function(b){d.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return d.offset.bodyOffset(b);d.offset.initialize();var c,e=b.offsetParent,f=b,g=b.ownerDocument,h=g.documentElement,i=g.body,j=g.defaultView,k=j?j.getComputedStyle(b,null):b.currentStyle,l=b.offsetTop,m=b.offsetLeft;while((b=b.parentNode)&&b!==i&&b!==h){if(d.offset.supportsFixedPosition&&k.position==="fixed")break;c=j?j.getComputedStyle(b,null):b.currentStyle,l-=b.scrollTop,m-=b.scrollLeft,b===e&&(l+=b.offsetTop,m+=b.offsetLeft,d.offset.doesNotAddBorder&&(!d.offset.doesAddBorderForTableAndCells||!cg.test(b.nodeName))&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),f=e,e=b.offsetParent),d.offset.subtractsBorderForOverflowNotVisible&&c.overflow!=="visible"&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),k=c}if(k.position==="relative"||k.position==="static")l+=i.offsetTop,m+=i.offsetLeft;d.offset.supportsFixedPosition&&k.position==="fixed"&&(l+=Math.max(h.scrollTop,i.scrollTop),m+=Math.max(h.scrollLeft,i.scrollLeft));return{top:l,left:m}},d.offset={initialize:function(){var a=c.body,b=c.createElement("div"),e,f,g,h,i=parseFloat(d.css(a,"marginTop"))||0,j="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";d.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"}),b.innerHTML=j,a.insertBefore(b,a.firstChild),e=b.firstChild,f=e.firstChild,h=e.nextSibling.firstChild.firstChild,this.doesNotAddBorder=f.offsetTop!==5,this.doesAddBorderForTableAndCells=h.offsetTop===5,f.style.position="fixed",f.style.top="20px",this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15,f.style.position=f.style.top="",e.style.overflow="hidden",e.style.position="relative",this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5,this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==i,a.removeChild(b),d.offset.initialize=d.noop},bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;d.offset.initialize(),d.offset.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(d.css(a,"marginTop"))||0,c+=parseFloat(d.css(a,"marginLeft"))||0);return{top:b,left:c}},setOffset:function(a,b,c){var e=d.css(a,"position");e==="static"&&(a.style.position="relative");var f=d(a),g=f.offset(),h=d.css(a,"top"),i=d.css(a,"left"),j=(e==="absolute"||e==="fixed")&&d.inArray("auto",[h,i])>-1,k={},l={},m,n;j&&(l=f.position()),m=j?l.top:parseInt(h,10)||0,n=j?l.left:parseInt(i,10)||0,d.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):f.css(k)}},d.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),e=ch.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(d.css(a,"marginTop"))||0,c.left-=parseFloat(d.css(a,"marginLeft"))||0,e.top+=parseFloat(d.css(b[0],"borderTopWidth"))||0,e.left+=parseFloat(d.css(b[0],"borderLeftWidth"))||0;return{top:c.top-e.top,left:c.left-e.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&(!ch.test(a.nodeName)&&d.css(a,"position")==="static"))a=a.offsetParent;return a})}}),d.each(["Left","Top"],function(a,c){var e="scroll"+c;d.fn[e]=function(c){var f=this[0],g;if(!f)return null;if(c!==b)return this.each(function(){g=ci(this),g?g.scrollTo(a?d(g).scrollLeft():c,a?c:d(g).scrollTop()):this[e]=c});g=ci(f);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:d.support.boxModel&&g.document.documentElement[e]||g.document.body[e]:f[e]}}),d.each(["Height","Width"],function(a,c){var e=c.toLowerCase();d.fn["inner"+c]=function(){return this[0]?parseFloat(d.css(this[0],e,"padding")):null},d.fn["outer"+c]=function(a){return this[0]?parseFloat(d.css(this[0],e,a?"margin":"border")):null},d.fn[e]=function(a){var f=this[0];if(!f)return a==null?null:this;if(d.isFunction(a))return this.each(function(b){var c=d(this);c[e](a.call(this,b,c[e]()))});if(d.isWindow(f)){var g=f.document.documentElement["client"+c];return f.document.compatMode==="CSS1Compat"&&g||f.document.body["client"+c]||g}if(f.nodeType===9)return Math.max(f.documentElement["client"+c],f.body["scroll"+c],f.documentElement["scroll"+c],f.body["offset"+c],f.documentElement["offset"+c]);if(a===b){var h=d.css(f,e),i=parseFloat(h);return d.isNaN(i)?h:i}return this.css(e,typeof a==="string"?a:a+"px")}}),a.jQuery=a.$=d})(window);
\ No newline at end of file
diff --git a/y2022/image_streamer/www_defaults/_seasocks.css b/y2022/image_streamer/www_defaults/_seasocks.css
new file mode 100644
index 0000000..03a7287
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_seasocks.css
@@ -0,0 +1,22 @@
+body {
+    font-family: segoe ui, tahoma, arial, sans-serif;
+    font-size: 12px;
+    color: #ffffff;
+    background-color: #333333;
+    margin: 0;
+}
+
+a {
+    color: #ffff00;
+}
+
+table {
+    border-collapse: collapse;
+    width: 100%;
+    text-align: center;
+}
+
+.template {
+    display: none;
+}
+
diff --git a/y2022/image_streamer/www_defaults/_stats.html b/y2022/image_streamer/www_defaults/_stats.html
new file mode 100644
index 0000000..d34e932
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/_stats.html
@@ -0,0 +1,60 @@
+<html DOCTYPE=html>
+<head>
+  <title>SeaSocks Stats</title>
+  <link href="/_seasocks.css" rel="stylesheet">
+  <script src="/_jquery.min.js" type="text/javascript"></script>
+  <script>
+  function clear() {
+    $('#cx tbody tr:visible').remove();
+  }
+  function connection(stats) {
+  	c = $('#cx .template').clone().removeClass('template').appendTo('#cx');
+  	for (stat in stats) {
+  	  c.find('.' + stat).text(stats[stat]);
+    }
+  }
+  function refresh() {
+  		var stats = new XMLHttpRequest();
+		stats.open("GET", "/_livestats.js", false);
+		stats.send(null);
+		eval(stats.responseText);
+  }
+  $(function() {
+  	setInterval(refresh, 1000);
+  	refresh();		
+  });
+  </script>
+</head>
+<body><h1>SeaSocks Stats</h1></body>
+
+<h2>Connections</h2>
+<table id="cx">
+  <thead>
+    <tr>
+      <th>Connection time</th>
+      <th>Fd</th>
+      <th>Addr</th>
+      <th>URI</th>
+      <th>Username</th>
+      <th>Pending read</th>
+      <th>Bytes read</th>
+      <th>Pending send</th>
+      <th>Bytes sent</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr class="template">
+      <td class="since"></td>
+      <td class="fd"></td>
+      <td class="addr"></td>
+      <td class="uri"></td>
+      <td class="user"></td>
+      <td class="input"></td>
+      <td class="read"></td>
+      <td class="output"></td>
+      <td class="written"></td>
+    </tr>
+  </tbody>
+</table>
+
+</body></html>
diff --git a/y2022/image_streamer/www_defaults/favicon.ico b/y2022/image_streamer/www_defaults/favicon.ico
new file mode 100644
index 0000000..30a95b9
--- /dev/null
+++ b/y2022/image_streamer/www_defaults/favicon.ico
Binary files differ
diff --git a/y2022/joystick_reader.cc b/y2022/joystick_reader.cc
index 653e1c1..05f3008 100644
--- a/y2022/joystick_reader.cc
+++ b/y2022/joystick_reader.cc
@@ -45,7 +45,8 @@
 
 const ButtonLocation kIntakeFrontOut(4, 10);
 const ButtonLocation kIntakeBackOut(4, 9);
-const ButtonLocation kSpit(3, 3);
+const ButtonLocation kSpitFront(3, 3);
+const ButtonLocation kSpitBack(2, 3);
 
 const ButtonLocation kRedLocalizerReset(3, 13);
 const ButtonLocation kBlueLocalizerReset(3, 14);
@@ -55,14 +56,16 @@
 const ButtonLocation kCatapultPos(4, 3);
 const ButtonLocation kFire(4, 1);
 const ButtonLocation kTurret(4, 15);
-const ButtonLocation kAutoAim(4, 2);
+const ButtonLocation kAutoAim(4, 16);
 
-const ButtonLocation kClimberExtend(4, 6);
+const ButtonLocation kClimberExtend(1, 2);
 const ButtonLocation kClimberIntakes(4, 5);
+const ButtonLocation kClimberServo(4, 4);
 
 const ButtonLocation kIntakeFrontOut(4, 10);
 const ButtonLocation kIntakeBackOut(4, 9);
-const ButtonLocation kSpit(3, 3);
+const ButtonLocation kSpitFront(3, 3);
+const ButtonLocation kSpitBack(3, 1);
 
 const ButtonLocation kRedLocalizerReset(4, 14);
 const ButtonLocation kBlueLocalizerReset(4, 13);
@@ -165,17 +168,17 @@
     constexpr double kIntakeUpPosition = 1.47;
     double intake_front_pos = kIntakeUpPosition;
     double intake_back_pos = kIntakeUpPosition;
-    double transfer_roller_front_speed = 0.0;
-    double transfer_roller_back_speed = 0.0;
+    double transfer_roller_speed = 0.0;
     std::optional<control_loops::superstructure::RequestedIntake>
         requested_intake;
 
     double roller_front_speed = 0.0;
     double roller_back_speed = 0.0;
 
-    std::optional<double> turret_pos = 0.0;
+    std::optional<double> turret_pos = std::nullopt;
 
     double climber_position = 0.01;
+    bool climber_servo = false;
 
     double catapult_pos = 0.03;
     double catapult_speed = 18.0;
@@ -194,9 +197,13 @@
     }
 
     if (data.IsPressed(kClimberExtend)) {
-      climber_position = 0.50;
+      climber_position = 0.54;
     } else {
-      climber_position = 0.01;
+      climber_position = 0.005;
+    }
+
+    if (data.IsPressed(kClimberServo)) {
+      climber_servo = true;
     }
 
     if (data.IsPressed(kTurret)) {
@@ -215,34 +222,38 @@
     // Keep the catapult return position at the shot one if kCatapultPos is
     // pressed
     if (data.IsPressed(kCatapultPos)) {
-      catapult_return_pos = 0.3;
+      catapult_return_pos = 0.7;
     } else {
       catapult_return_pos = -0.908;
     }
 
-    constexpr double kRollerSpeed = 8.0;
+    constexpr double kRollerSpeed = 12.0;
     constexpr double kTransferRollerSpeed = 12.0;
-    constexpr double kIntakePosition = -0.02;
+    constexpr double kIntakePosition = -0.12;
     constexpr size_t kIntakeCounterIterations = 25;
 
-    // Extend the intakes and spin the rollers
-    if (data.IsPressed(kIntakeFrontOut)) {
+    // Extend the intakes and spin the rollers.
+    // Don't let this happen if there is a ball in the other intake, because
+    // that would spit this one out.
+    if (data.IsPressed(kIntakeFrontOut) &&
+        !superstructure_status_fetcher_->back_intake_has_ball()) {
       intake_front_pos = kIntakePosition;
-      transfer_roller_front_speed = kTransferRollerSpeed;
+      transfer_roller_speed = kTransferRollerSpeed;
 
       intake_front_counter_ = kIntakeCounterIterations;
       intake_back_counter_ = 0;
-    } else if (data.IsPressed(kIntakeBackOut)) {
+    } else if (data.IsPressed(kIntakeBackOut) &&
+               !superstructure_status_fetcher_->front_intake_has_ball()) {
       intake_back_pos = kIntakePosition;
-      transfer_roller_back_speed = kTransferRollerSpeed;
+      transfer_roller_speed = -kTransferRollerSpeed;
 
       intake_back_counter_ = kIntakeCounterIterations;
       intake_front_counter_ = 0;
-    } else if (data.IsPressed(kSpit)) {
-      transfer_roller_front_speed = -kTransferRollerSpeed;
-      transfer_roller_back_speed = -kTransferRollerSpeed;
-
+    } else if (data.IsPressed(kSpitFront)) {
+      transfer_roller_speed = -kTransferRollerSpeed;
       intake_front_counter_ = 0;
+    } else if (data.IsPressed(kSpitBack)) {
+      transfer_roller_speed = kTransferRollerSpeed;
       intake_back_counter_ = 0;
     }
 
@@ -261,7 +272,6 @@
     if (data.IsPressed(kFire)) {
       fire = true;
       // Provide a default turret goal.
-      turret_pos = 0.0;
     }
 
     if (data.IsPressed(kClimberIntakes)) {
@@ -300,7 +310,7 @@
       flatbuffers::Offset<StaticZeroingSingleDOFProfiledSubsystemGoal>
           climber_offset = CreateStaticZeroingSingleDOFProfiledSubsystemGoal(
               *builder.fbb(), climber_position,
-              frc971::CreateProfileParameters(*builder.fbb(), 1.0, 5.0));
+              frc971::CreateProfileParameters(*builder.fbb(), 1.0, 1.0));
 
       superstructure::CatapultGoal::Builder catapult_builder =
           builder.MakeBuilder<superstructure::CatapultGoal>();
@@ -324,10 +334,9 @@
 
       superstructure_goal_builder.add_roller_speed_front(roller_front_speed);
       superstructure_goal_builder.add_roller_speed_back(roller_back_speed);
-      superstructure_goal_builder.add_transfer_roller_speed_front(
-          transfer_roller_front_speed);
-      superstructure_goal_builder.add_transfer_roller_speed_back(
-          transfer_roller_back_speed);
+      superstructure_goal_builder.add_transfer_roller_speed(
+          transfer_roller_speed);
+      superstructure_goal_builder.add_climber_servo(climber_servo);
       superstructure_goal_builder.add_auto_aim(data.IsPressed(kAutoAim));
       if (requested_intake.has_value()) {
         superstructure_goal_builder.add_turret_intake(requested_intake.value());
diff --git a/y2022/localizer/localizer.cc b/y2022/localizer/localizer.cc
index 954bffc..783d368 100644
--- a/y2022/localizer/localizer.cc
+++ b/y2022/localizer/localizer.cc
@@ -642,7 +642,7 @@
   H_model(1, kY) = 1.0;
   H_accel(0, kX) = 1.0;
   H_accel(1, kY) = 1.0;
-  R.diagonal() << 1e-0, 1e-0;
+  R.diagonal() << 1e-2, 1e-2;
 
   const Eigen::Matrix<double, kNModelStates, 2> K_model =
       P_model_ * H_model.transpose() *
@@ -954,6 +954,7 @@
           model_based_.TallyRejection(RejectionReason::IMAGE_FROM_FUTURE);
           continue;
         }
+        capture_time -= pico_offset_error_;
         model_based_.HandleImageMatch(
             capture_time, target_estimate_fetchers_[camera_index].get(),
             camera_index);
diff --git a/y2022/message_bridge_client.sh b/y2022/message_bridge_client.sh
new file mode 100755
index 0000000..c81076a
--- /dev/null
+++ b/y2022/message_bridge_client.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+while true;
+do
+  ping -c 1 pi1 -W 1 && break;
+  sleep 1
+done
+
+echo Pinged
+
+exec /home/admin/bin/message_bridge_client "$@"
diff --git a/y2022/vision/BUILD b/y2022/vision/BUILD
index a26c507..65ab20c 100644
--- a/y2022/vision/BUILD
+++ b/y2022/vision/BUILD
@@ -149,6 +149,73 @@
     ],
 )
 
+cc_binary(
+    name = "ball_color_detector",
+    srcs = [
+        "ball_color_main.cc",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+    visibility = ["//y2022:__subpackages__"],
+    deps = [
+        ":ball_color_lib",
+        "//aos:init",
+        "//aos/events:shm_event_loop",
+    ],
+)
+
+cc_test(
+    name = "ball_color_test",
+    srcs = [
+        "ball_color_test.cc",
+    ],
+    data = [
+        "test_ball_color_image.jpg",
+    ],
+    deps = [
+        ":ball_color_lib",
+        "//aos:json_to_flatbuffer",
+        "//aos/events:simulated_event_loop",
+        "//aos/testing:googletest",
+        "//aos/testing:test_logging",
+        "//y2022:constants",
+    ],
+)
+
+cc_library(
+    name = "ball_color_lib",
+    srcs = [
+        "ball_color.cc",
+    ],
+    hdrs = [
+        "ball_color.h",
+    ],
+    data = [
+        "//y2022:aos_config",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+    visibility = ["//y2022:__subpackages__"],
+    deps = [
+        ":ball_color_fbs",
+        "//aos/events:event_loop",
+        "//aos/events:shm_event_loop",
+        "//aos/network:team_number",
+        "//frc971/input:joystick_state_fbs",
+        "//frc971/vision:vision_fbs",
+        "//third_party:opencv",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "ball_color_fbs",
+    srcs = ["ball_color.fbs"],
+    gen_reflections = 1,
+    includes = [
+        "//frc971/input:joystick_state_fbs_includes",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+    visibility = ["//y2022:__subpackages__"],
+)
+
 cc_library(
     name = "geometry_lib",
     hdrs = [
diff --git a/y2022/vision/ball_color.cc b/y2022/vision/ball_color.cc
new file mode 100644
index 0000000..e896da5
--- /dev/null
+++ b/y2022/vision/ball_color.cc
@@ -0,0 +1,138 @@
+#include "y2022/vision/ball_color.h"
+
+#include <chrono>
+#include <cmath>
+#include <opencv2/highgui/highgui.hpp>
+#include <thread>
+
+#include "aos/events/event_loop.h"
+#include "aos/events/shm_event_loop.h"
+#include "frc971/input/joystick_state_generated.h"
+#include "frc971/vision/vision_generated.h"
+#include "glog/logging.h"
+#include "opencv2/imgproc.hpp"
+
+namespace y2022 {
+namespace vision {
+
+BallColorDetector::BallColorDetector(aos::EventLoop *event_loop)
+    : ball_color_sender_(event_loop->MakeSender<BallColor>("/superstructure")) {
+  event_loop->MakeWatcher("/camera", [this](const CameraImage &camera_image) {
+    this->ProcessImage(camera_image);
+  });
+}
+
+void BallColorDetector::ProcessImage(const CameraImage &image) {
+  cv::Mat image_color_mat(cv::Size(image.cols(), image.rows()), CV_8UC2,
+                          (void *)image.data()->data());
+  cv::Mat image_mat(cv::Size(image.cols(), image.rows()), CV_8UC3);
+  cv::cvtColor(image_color_mat, image_mat, cv::COLOR_YUV2BGR_YUYV);
+
+  aos::Alliance detected_color = DetectColor(image_mat);
+
+  auto builder = ball_color_sender_.MakeBuilder();
+  auto ball_color_builder = builder.MakeBuilder<BallColor>();
+  ball_color_builder.add_ball_color(detected_color);
+  builder.CheckOk(builder.Send(ball_color_builder.Finish()));
+}
+
+aos::Alliance BallColorDetector::DetectColor(cv::Mat image) {
+  cv::Mat hsv(cv::Size(image.cols, image.rows), CV_8UC3);
+
+  cv::cvtColor(image, hsv, cv::COLOR_BGR2HSV);
+
+  // Look at 3 chunks of the image
+  cv::Mat reference_red =
+      BallColorDetector::SubImage(hsv, BallColorDetector::kReferenceRed());
+
+  cv::Mat reference_blue =
+      BallColorDetector::SubImage(hsv, BallColorDetector::kReferenceBlue());
+  cv::Mat ball_location =
+      BallColorDetector::SubImage(hsv, BallColorDetector::kBallLocation());
+
+  // OpenCV HSV hues go from [0 to 179]
+  // Average the average color of each patch in both directions
+  // Rejecting pixels that have too low saturation or to bright or dark value
+  // And dealing with the wrapping of the red hues by shifting the wrap to be
+  // around 90 instead of 180. 90 is a color we don't care about.
+  double red = BallColorDetector::mean_hue(reference_red);
+  double blue = BallColorDetector::mean_hue(reference_blue);
+  double ball = BallColorDetector::mean_hue(ball_location);
+
+  // Just look at the hue values for distance
+  const double distance_to_blue = std::abs(ball - blue);
+  const double distance_to_red = std::abs(ball - red);
+
+  VLOG(1) << "\n"
+          << "Red: " << red << " deg\n"
+          << "Blue: " << blue << " deg\n"
+          << "Ball: " << ball << " deg\n"
+          << "distance to blue: " << distance_to_blue << " "
+          << "distance_to_red: " << distance_to_red;
+
+  // Is the ball location close enough to being the same hue as the blue
+  // reference or the red reference?
+
+  if (distance_to_blue < distance_to_red &&
+      distance_to_blue < kMaxHueDistance) {
+    return aos::Alliance::kBlue;
+  } else if (distance_to_red < distance_to_blue &&
+             distance_to_red < kMaxHueDistance) {
+    return aos::Alliance::kRed;
+  }
+
+  return aos::Alliance::kInvalid;
+}
+
+cv::Mat BallColorDetector::SubImage(cv::Mat image, cv::Rect location) {
+  cv::Rect new_location = BallColorDetector::RescaleRect(
+      image, location, BallColorDetector::kMeasurementsImageSize());
+  return image(new_location);
+}
+
+// Handle varying size images by scaling our constants rectangles
+cv::Rect BallColorDetector::RescaleRect(cv::Mat image, cv::Rect location,
+                                        cv::Size original_size) {
+  const double x_scale = static_cast<double>(image.cols) / original_size.width;
+  const double y_scale = static_cast<double>(image.rows) / original_size.height;
+
+  cv::Rect new_location(location.x * x_scale, location.y * y_scale,
+                        location.width * x_scale, location.height * y_scale);
+
+  return new_location;
+}
+
+double BallColorDetector::mean_hue(cv::Mat hsv_image) {
+  double num_pixels_selected = 0;
+  double sum = 0;
+
+  for (int i = 0; i < hsv_image.rows; ++i) {
+    for (int j = 0; j < hsv_image.cols; ++j) {
+      const cv::Vec3b &color = hsv_image.at<cv::Vec3b>(i, j);
+      double value = static_cast<double>(color(2));
+      double saturation = static_cast<double>(color(1));
+
+      if (value < kMinValue || value > kMaxValue ||
+          saturation < kMinSaturation) {
+        continue;
+      }
+
+      // unwrap hue so that break is around 90 instead of 180
+      // ex. a hue of 180 goes to 0, a hue of 120 goes to -60
+      // but there's still a break around 90 where it will be either +- 90
+      // depending on which side it's on
+      double hue = static_cast<double>(color(0));
+      if (hue > 90) {
+        hue = hue - 180;
+      }
+
+      num_pixels_selected++;
+      sum += hue;
+    }
+  }
+
+  return sum / num_pixels_selected;
+}
+
+}  // namespace vision
+}  // namespace y2022
diff --git a/y2022/vision/ball_color.fbs b/y2022/vision/ball_color.fbs
new file mode 100644
index 0000000..7eb93e0
--- /dev/null
+++ b/y2022/vision/ball_color.fbs
@@ -0,0 +1,12 @@
+include "frc971/input/joystick_state.fbs";
+
+namespace y2022.vision;
+
+table BallColor {
+  // The color of the ball represented as which alliance it belongs to
+  // it will be unpredictable when there is no ball and it will be kInvalid
+  // if the color is not close enough to either of the two references.
+  ball_color:aos.Alliance (id: 0);
+}
+
+root_type BallColor;
diff --git a/y2022/vision/ball_color.h b/y2022/vision/ball_color.h
new file mode 100644
index 0000000..ef3bdd2
--- /dev/null
+++ b/y2022/vision/ball_color.h
@@ -0,0 +1,58 @@
+#ifndef Y2022_VISION_BALL_COLOR_H_
+#define Y2022_VISION_BALL_COLOR_H_
+
+#include <opencv2/imgproc.hpp>
+
+#include "aos/events/shm_event_loop.h"
+#include "frc971/input/joystick_state_generated.h"
+#include "frc971/vision/vision_generated.h"
+#include "y2022/vision/ball_color_generated.h"
+
+namespace y2022 {
+namespace vision {
+
+using namespace frc971::vision;
+
+// Takes in camera images and detects what color the loaded ball is
+// Does not detect if there is a ball, and will output bad measurements in
+// the case that that there is not a ball.
+class BallColorDetector {
+ public:
+  // The size image that the reference rectangles were measure with
+  // These constants will be scaled if the image sent is not the same size
+  static const cv::Size kMeasurementsImageSize() { return {640, 480}; };
+  static const cv::Rect kReferenceRed() { return {440, 150, 50, 130}; };
+  static const cv::Rect kReferenceBlue() { return {440, 350, 30, 100}; };
+  static const cv::Rect kBallLocation() { return {100, 400, 140, 50}; };
+
+  // Constants used to filter out pixels that don't have good color information
+  static constexpr double kMinSaturation = 128;
+  static constexpr double kMinValue = 25;
+  static constexpr double kMaxValue = 230;
+
+  static constexpr double kMaxHueDistance = 10;
+
+  BallColorDetector(aos::EventLoop *event_loop);
+
+  void ProcessImage(const CameraImage &camera_image);
+
+  // We look at three parts of the image: two reference locations where there
+  // will be red and blue markers that should match the ball, and then the
+  // location in the catapult where we expect to see the ball. We then compute
+  // the average hue of each patch but discard pixels that we deem not colorful
+  // enough. Then we decide whether the ball color looks close enough to either
+  // of the reference colors. If no good color is detected, outputs kInvalid.
+  static aos::Alliance DetectColor(cv::Mat image);
+
+  static cv::Mat SubImage(cv::Mat image, cv::Rect location);
+
+  static cv::Rect RescaleRect(cv::Mat image, cv::Rect location,
+                              cv::Size original_size);
+  static double mean_hue(cv::Mat hsv_image);
+
+ private:
+  aos::Sender<BallColor> ball_color_sender_;
+};
+}  // namespace vision
+}  // namespace y2022
+#endif
diff --git a/y2022/vision/ball_color_main.cc b/y2022/vision/ball_color_main.cc
new file mode 100644
index 0000000..63f9d06
--- /dev/null
+++ b/y2022/vision/ball_color_main.cc
@@ -0,0 +1,35 @@
+#include "aos/events/shm_event_loop.h"
+#include "aos/init.h"
+#include "y2022/vision/ball_color.h"
+
+// config used to allow running ball_color_detector independently.  E.g.,
+// bazel run //y2022/vision:ball_color_detector -- --config
+// y2022/aos_config.json
+//   --override_hostname pi-7971-1  --ignore_timestamps true
+DEFINE_string(config, "aos_config.json", "Path to the config file to use.");
+
+namespace y2022 {
+namespace vision {
+namespace {
+
+using namespace frc971::vision;
+
+void BallColorDetectorMain() {
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config =
+      aos::configuration::ReadConfig(FLAGS_config);
+
+  aos::ShmEventLoop event_loop(&config.message());
+
+  BallColorDetector ball_color_detector(&event_loop);
+
+  event_loop.Run();
+}
+
+}  // namespace
+}  // namespace vision
+}  // namespace y2022
+
+int main(int argc, char **argv) {
+  aos::InitGoogle(&argc, &argv);
+  y2022::vision::BallColorDetectorMain();
+}
diff --git a/y2022/vision/ball_color_test.cc b/y2022/vision/ball_color_test.cc
new file mode 100644
index 0000000..695791b
--- /dev/null
+++ b/y2022/vision/ball_color_test.cc
@@ -0,0 +1,147 @@
+#include "y2022/vision/ball_color.h"
+
+#include <cmath>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include "aos/events/simulated_event_loop.h"
+#include "aos/json_to_flatbuffer.h"
+#include "aos/testing/test_logging.h"
+#include "glog/logging.h"
+#include "gtest/gtest.h"
+#include "y2022/constants.h"
+
+DEFINE_string(output_folder, "",
+              "If set, logs all channels to the provided logfile.");
+
+namespace y2022::vision::testing {
+
+class BallColorTest : public ::testing::Test {
+ public:
+  BallColorTest()
+      : config_(aos::configuration::ReadConfig("y2022/aos_config.json")),
+        event_loop_factory_(&config_.message()),
+        logger_pi_(aos::configuration::GetNode(
+            event_loop_factory_.configuration(), "logger")),
+        roborio_(aos::configuration::GetNode(
+            event_loop_factory_.configuration(), "roborio")),
+        camera_event_loop_(
+            event_loop_factory_.MakeEventLoop("Camera", logger_pi_)),
+        color_detector_event_loop_(event_loop_factory_.MakeEventLoop(
+            "Ball color detector", logger_pi_)),
+        superstructure_event_loop_(
+            event_loop_factory_.MakeEventLoop("Superstructure", roborio_)),
+        ball_color_fetcher_(superstructure_event_loop_->MakeFetcher<BallColor>(
+            "/superstructure")),
+        image_sender_(camera_event_loop_->MakeSender<CameraImage>("/camera"))
+
+  {}
+
+  // copied from camera_reader.cc
+  void SendImage(cv::Mat bgr_image) {
+    cv::Mat image_color_mat;
+    cv::cvtColor(bgr_image, image_color_mat, cv::COLOR_BGR2YUV);
+
+    // Convert YUV (3 channels) to YUYV (stacked format)
+    std::vector<uint8_t> yuyv;
+    for (int i = 0; i < image_color_mat.rows; i++) {
+      for (int j = 0; j < image_color_mat.cols; j++) {
+        // Always push a Y value
+        yuyv.emplace_back(image_color_mat.at<cv::Vec3b>(i, j)[0]);
+        if ((j % 2) == 0) {
+          // If column # is even, push a U value.
+          yuyv.emplace_back(image_color_mat.at<cv::Vec3b>(i, j)[1]);
+        } else {
+          // If column # is odd, push a V value.
+          yuyv.emplace_back(image_color_mat.at<cv::Vec3b>(i, j)[2]);
+        }
+      }
+    }
+
+    CHECK_EQ(static_cast<int>(yuyv.size()),
+             image_color_mat.rows * image_color_mat.cols * 2);
+
+    auto builder = image_sender_.MakeBuilder();
+    auto image_offset = builder.fbb()->CreateVector(yuyv);
+    auto image_builder = builder.MakeBuilder<CameraImage>();
+
+    int64_t timestamp = aos::monotonic_clock::now().time_since_epoch().count();
+
+    image_builder.add_rows(image_color_mat.rows);
+    image_builder.add_cols(image_color_mat.cols);
+    image_builder.add_data(image_offset);
+    image_builder.add_monotonic_timestamp_ns(timestamp);
+
+    builder.CheckOk(builder.Send(image_builder.Finish()));
+  }
+
+  aos::FlatbufferDetachedBuffer<aos::Configuration> config_;
+  aos::SimulatedEventLoopFactory event_loop_factory_;
+  const aos::Node *const logger_pi_;
+  const aos::Node *const roborio_;
+  ::std::unique_ptr<::aos::EventLoop> camera_event_loop_;
+  ::std::unique_ptr<::aos::EventLoop> color_detector_event_loop_;
+  ::std::unique_ptr<::aos::EventLoop> superstructure_event_loop_;
+  aos::Fetcher<BallColor> ball_color_fetcher_;
+  aos::Sender<CameraImage> image_sender_;
+};
+
+TEST_F(BallColorTest, DetectColorFromTestImage) {
+  cv::Mat bgr_image =
+      cv::imread("y2022/vision/test_ball_color_image.jpg", cv::IMREAD_COLOR);
+
+  ASSERT_TRUE(bgr_image.data != nullptr);
+
+  aos::Alliance detected_color = BallColorDetector::DetectColor(bgr_image);
+
+  EXPECT_EQ(detected_color, aos::Alliance::kRed);
+}
+
+TEST_F(BallColorTest, DetectColorFromTestImageInEventLoop) {
+  cv::Mat bgr_image =
+      cv::imread("y2022/vision/test_ball_color_image.jpg", cv::IMREAD_COLOR);
+  ASSERT_TRUE(bgr_image.data != nullptr);
+
+  BallColorDetector detector(color_detector_event_loop_.get());
+
+  camera_event_loop_->OnRun([this, bgr_image]() { SendImage(bgr_image); });
+
+  event_loop_factory_.RunFor(std::chrono::milliseconds(5));
+
+  ASSERT_TRUE(ball_color_fetcher_.Fetch());
+
+  EXPECT_TRUE(ball_color_fetcher_->has_ball_color());
+  EXPECT_EQ(ball_color_fetcher_->ball_color(), aos::Alliance::kRed);
+}
+
+TEST_F(BallColorTest, TestRescaling) {
+  cv::Mat mat(cv::Size(320, 240), CV_8UC3);
+  cv::Rect new_rect = BallColorDetector::RescaleRect(
+      mat, cv::Rect(30, 30, 30, 30), cv::Size(1920, 1080));
+
+  EXPECT_EQ(new_rect, cv::Rect(5, 6, 5, 6));
+}
+
+TEST_F(BallColorTest, TestAreas) {
+  cv::Mat bgr_image =
+      cv::imread("y2022/vision/test_ball_color_image.jpg", cv::IMREAD_COLOR);
+  ASSERT_TRUE(bgr_image.data != nullptr);
+
+  cv::Rect reference_red = BallColorDetector::RescaleRect(
+      bgr_image, BallColorDetector::kReferenceRed(),
+      BallColorDetector::kMeasurementsImageSize());
+  cv::Rect reference_blue = BallColorDetector::RescaleRect(
+      bgr_image, BallColorDetector::kReferenceBlue(),
+      BallColorDetector::kMeasurementsImageSize());
+  cv::Rect ball_location = BallColorDetector::RescaleRect(
+      bgr_image, BallColorDetector::kBallLocation(),
+      BallColorDetector::kMeasurementsImageSize());
+
+  cv::rectangle(bgr_image, reference_red, cv::Scalar(0, 0, 255));
+  cv::rectangle(bgr_image, reference_blue, cv::Scalar(255, 0, 0));
+  cv::rectangle(bgr_image, ball_location, cv::Scalar(0, 255, 0));
+
+  cv::imwrite("/tmp/rectangles.jpg", bgr_image);
+}
+
+}  // namespace y2022::vision::testing
diff --git a/y2022/vision/blob_detector.cc b/y2022/vision/blob_detector.cc
index efe7961..93c72d7 100644
--- a/y2022/vision/blob_detector.cc
+++ b/y2022/vision/blob_detector.cc
@@ -11,15 +11,30 @@
 #include "opencv2/imgproc.hpp"
 #include "y2022/vision/geometry.h"
 
+DEFINE_bool(
+    use_outdoors, true,
+    "If set, use the color filters and exposure for an outdoor setting.");
 DEFINE_int32(red_delta, 50, "Required difference between green pixels vs. red");
 DEFINE_int32(blue_delta, -20,
              "Required difference between green pixels vs. blue");
+DEFINE_int32(outdoors_red_delta, 70,
+             "Required difference between green pixels vs. red when using "
+             "--use_outdoors");
+DEFINE_int32(outdoors_blue_delta, -10,
+             "Required difference between green pixels vs. blue when using "
+             "--use_outdoors");
 
 namespace y2022 {
 namespace vision {
 
 cv::Mat BlobDetector::ThresholdImage(cv::Mat bgr_image) {
   cv::Mat binarized_image(cv::Size(bgr_image.cols, bgr_image.rows), CV_8UC1);
+
+  const int red_delta =
+      (FLAGS_use_outdoors ? FLAGS_outdoors_red_delta : FLAGS_red_delta);
+  const int blue_delta =
+      (FLAGS_use_outdoors ? FLAGS_outdoors_blue_delta : FLAGS_blue_delta);
+
   for (int row = 0; row < bgr_image.rows; row++) {
     for (int col = 0; col < bgr_image.cols; col++) {
       cv::Vec3b pixel = bgr_image.at<cv::Vec3b>(row, col);
@@ -28,8 +43,7 @@
       int red = pixel.val[2];
       // Simple filter that looks for green pixels sufficiently brigher than
       // red and blue
-      if ((green > blue + FLAGS_blue_delta) &&
-          (green > red + FLAGS_red_delta)) {
+      if ((green > blue + blue_delta) && (green > red + red_delta)) {
         binarized_image.at<uint8_t>(row, col) = 255;
       } else {
         binarized_image.at<uint8_t>(row, col) = 0;
@@ -119,7 +133,7 @@
   }
 
   // Threshold for mean distance from a blob centroid to a circle.
-  constexpr double kCircleDistanceThreshold = 10.0;
+  constexpr double kCircleDistanceThreshold = 1.0;
   // We should only expect to see blobs between these angles on a circle.
   constexpr double kDegToRad = M_PI / 180.0;
   constexpr double kMinBlobAngle = 50.0 * kDegToRad;
@@ -233,10 +247,6 @@
     cv::circle(view_image, stats.centroid, kCircleRadius, cv::Scalar(0, 255, 0),
                cv::FILLED);
   }
-
-  // Draw average centroid
-  cv::circle(view_image, blob_result.centroid, kCircleRadius,
-             cv::Scalar(255, 255, 0), cv::FILLED);
 }
 
 void BlobDetector::ExtractBlobs(cv::Mat bgr_image,
diff --git a/y2022/vision/camera_definition.py b/y2022/vision/camera_definition.py
index 68549a4..f59f2cf 100644
--- a/y2022/vision/camera_definition.py
+++ b/y2022/vision/camera_definition.py
@@ -100,13 +100,13 @@
 
     if pi_number == "pi1":
         camera_yaw = 90.0 * np.pi / 180.0
-        T = np.array([-7.0 * 0.0254, 3.5 * 0.0254, 32.0 * 0.0254])
+        T = np.array([-8.25 * 0.0254, 3.25 * 0.0254, 32.0 * 0.0254])
     elif pi_number == "pi2":
         camera_yaw = 0.0
-        T = np.array([-7.0 * 0.0254, -3.0 * 0.0254, 34.0 * 0.0254])
+        T = np.array([-7.5 * 0.0254, -3.5 * 0.0254, 34.0 * 0.0254])
     elif pi_number == "pi3":
-        camera_yaw = 180.0 * np.pi / 180.0
-        T = np.array([-1.0 * 0.0254, 8.5 * 0.0254, 34.0 * 0.0254])
+        camera_yaw = 178.5 * np.pi / 180.0
+        T = np.array([-1.0 * 0.0254, 8.5 * 0.0254, 34.25 * 0.0254])
     elif pi_number == "pi4":
         camera_yaw = -90.0 * np.pi / 180.0
         T = np.array([-9.0 * 0.0254, -5 * 0.0254, 27.5 * 0.0254])
diff --git a/y2022/vision/camera_reader.cc b/y2022/vision/camera_reader.cc
index 2fd581a..92d3727 100644
--- a/y2022/vision/camera_reader.cc
+++ b/y2022/vision/camera_reader.cc
@@ -90,8 +90,12 @@
 }
 }  // namespace
 
-void CameraReader::ProcessImage(cv::Mat image_mat,
+void CameraReader::ProcessImage(cv::Mat image_mat_distorted,
                                 int64_t image_monotonic_timestamp_ns) {
+  cv::Mat image_mat;
+  cv::undistort(image_mat_distorted, image_mat, CameraIntrinsics(),
+                CameraDistCoeffs());
+
   BlobDetector::BlobResult blob_result;
   BlobDetector::ExtractBlobs(image_mat, &blob_result);
   auto builder = target_estimate_sender_.MakeBuilder();
diff --git a/y2022/vision/camera_reader.h b/y2022/vision/camera_reader.h
index a777bcc..7128890 100644
--- a/y2022/vision/camera_reader.h
+++ b/y2022/vision/camera_reader.h
@@ -63,7 +63,8 @@
   const calibration::CameraCalibration *FindCameraCalibration() const;
 
   // Processes an image (including sending the results).
-  void ProcessImage(cv::Mat image, int64_t image_monotonic_timestamp_ns);
+  void ProcessImage(cv::Mat image_mat_distorted,
+                    int64_t image_monotonic_timestamp_ns);
 
   // Reads an image, and then performs all of our processing on it.
   void ReadImage();
diff --git a/y2022/vision/camera_reader_main.cc b/y2022/vision/camera_reader_main.cc
index dac2100..9320152 100644
--- a/y2022/vision/camera_reader_main.cc
+++ b/y2022/vision/camera_reader_main.cc
@@ -5,10 +5,14 @@
 // config used to allow running camera_reader independently.  E.g.,
 // bazel run //y2022/vision:camera_reader -- --config y2022/aos_config.json
 //   --override_hostname pi-7971-1  --ignore_timestamps true
+DECLARE_bool(use_outdoors);
 DEFINE_string(config, "aos_config.json", "Path to the config file to use.");
 DEFINE_double(duty_cycle, 0.6, "Duty cycle of the LEDs");
 DEFINE_uint32(exposure, 5,
               "Exposure time, in 100us increments; 0 implies auto exposure");
+DEFINE_uint32(outdoors_exposure, 20,
+              "Exposure time when using --use_outdoors, in 100us increments; 0 "
+              "implies auto exposure");
 
 namespace y2022 {
 namespace vision {
@@ -35,8 +39,10 @@
   }
 
   V4L2Reader v4l2_reader(&event_loop, "/dev/video0");
-  if (FLAGS_exposure > 0) {
-    v4l2_reader.SetExposure(FLAGS_exposure);
+  const uint32_t exposure =
+      (FLAGS_use_outdoors ? FLAGS_outdoors_exposure : FLAGS_exposure);
+  if (exposure > 0) {
+    v4l2_reader.SetExposure(exposure);
   }
 
   CameraReader camera_reader(&event_loop, &calibration_data.message(),
diff --git a/y2022/vision/target_estimator.cc b/y2022/vision/target_estimator.cc
index ba399b7..9eef390 100644
--- a/y2022/vision/target_estimator.cc
+++ b/y2022/vision/target_estimator.cc
@@ -24,6 +24,8 @@
               "Maximum number of iterations for the ceres solver");
 DEFINE_bool(solver_output, false,
             "If true, log the solver progress and results");
+DEFINE_bool(draw_projected_hub, true,
+            "If true, draw the projected hub when drawing an estimate");
 
 namespace y2022::vision {
 
@@ -36,7 +38,7 @@
 // Height of the center of the tape (m)
 constexpr double kTapeCenterHeight = 2.58 + (kTapePieceHeight / 2);
 // Horizontal distance from tape to center of hub (m)
-constexpr double kUpperHubRadius = 1.22 / 2;
+constexpr double kUpperHubRadius = 1.36 / 2;
 
 std::vector<cv::Point3d> ComputeTapePoints() {
   std::vector<cv::Point3d> tape_points;
@@ -96,14 +98,22 @@
 const std::array<cv::Point3d, 4> TargetEstimator::kMiddleTapePiecePoints =
     ComputeMiddleTapePiecePoints();
 
+namespace {
+constexpr double kDefaultDistance = 3.0;
+constexpr double kDefaultYaw = M_PI;
+constexpr double kDefaultAngleToCamera = 0.0;
+}  // namespace
+
 TargetEstimator::TargetEstimator(cv::Mat intrinsics, cv::Mat extrinsics)
     : blob_stats_(),
+      middle_blob_index_(0),
+      max_blob_area_(0.0),
       image_(std::nullopt),
       roll_(0.0),
       pitch_(0.0),
-      yaw_(M_PI),
-      distance_(3.0),
-      angle_to_camera_(0.0),
+      yaw_(kDefaultYaw),
+      distance_(kDefaultDistance),
+      angle_to_camera_(kDefaultAngleToCamera),
       // Seed camera height
       camera_height_(extrinsics.at<double>(2, 3) +
                      constants::Values::kImuHeight()) {
@@ -151,11 +161,17 @@
                    blob_stats_[2].centroid});
   CHECK(circle.has_value());
 
+  max_blob_area_ = 0.0;
+
   // Find the middle blob, which is the one with the angle closest to the
   // average
   double theta_avg = 0.0;
   for (const auto &stats : blob_stats_) {
     theta_avg += circle->AngleOf(stats.centroid);
+
+    if (stats.area > max_blob_area_) {
+      max_blob_area_ = stats.area;
+    }
   }
   theta_avg /= blob_stats_.size();
 
@@ -183,8 +199,9 @@
                                                ceres::DO_NOT_TAKE_OWNERSHIP);
 
   // TODO(milind): add loss function when we get more noisy data
-  problem.AddResidualBlock(cost_function, nullptr, &roll_, &pitch_, &yaw_,
-                           &distance_, &angle_to_camera_, &camera_height_);
+  problem.AddResidualBlock(cost_function, new ceres::HuberLoss(2.0), &roll_,
+                           &pitch_, &yaw_, &distance_, &angle_to_camera_,
+                           &camera_height_);
 
   // Compute the estimated rotation of the camera using the robot rotation.
   const Eigen::Matrix3d extrinsics_rot =
@@ -198,12 +215,31 @@
 
   // TODO(milind): seed with localizer output as well
 
+  // If we didn't solve well last time, seed everything at the defaults so we
+  // don't get stuck in a bad state.
+  // Copied from localizer.cc
+  constexpr double kMinConfidence = 0.75;
+  if (confidence_ < kMinConfidence) {
+    roll_ = roll_seed;
+    pitch_ = pitch_seed;
+    yaw_ = kDefaultYaw;
+    distance_ = kDefaultDistance;
+    angle_to_camera_ = kDefaultAngleToCamera;
+    camera_height_ = extrinsics_(2, 3) + constants::Values::kImuHeight();
+  }
+
   // Constrain the rotation to be around the localizer's, otherwise there can be
   // multiple solutions. There shouldn't be too much roll or pitch
+  if (FLAGS_freeze_roll) {
+    roll_ = roll_seed;
+  }
   constexpr double kMaxRollDelta = 0.1;
   SetBoundsOrFreeze(&roll_, FLAGS_freeze_roll, roll_seed - kMaxRollDelta,
                     roll_seed + kMaxRollDelta, &problem);
 
+  if (FLAGS_freeze_pitch) {
+    pitch_ = pitch_seed;
+  }
   constexpr double kMaxPitchDelta = 0.15;
   SetBoundsOrFreeze(&pitch_, FLAGS_freeze_pitch, pitch_seed - kMaxPitchDelta,
                     pitch_seed + kMaxPitchDelta, &problem);
@@ -241,7 +277,7 @@
           << std::chrono::duration<double, std::milli>(end - start).count()
           << " ms";
 
-  // For computing the confidence, find the standard deviation in pixels
+  // For computing the confidence, find the standard deviation in pixels.
   std::vector<double> residual(num_residuals);
   (*this)(&roll_, &pitch_, &yaw_, &distance_, &angle_to_camera_,
           &camera_height_, residual.data());
@@ -255,12 +291,12 @@
   // Use a sigmoid to convert the deviation into a confidence for the
   // localizer. Fit a sigmoid to the points of (0, 1) and two other
   // reasonable deviation-confidence combinations using
-  // https://www.desmos.com/calculator/try0pgx1qw
-  constexpr double kSigmoidCapacity = 1.045;
+  // https://www.desmos.com/calculator/ha6fh9yw44
+  constexpr double kSigmoidCapacity = 1.065;
   // Stretch the sigmoid out correctly.
-  // Currently, good estimates have deviations of around 2 pixels.
-  constexpr double kSigmoidScalar = 0.04452;
-  constexpr double kSigmoidGrowthRate = -0.4021;
+  // Currently, good estimates have deviations of 1 or less pixels.
+  constexpr double kSigmoidScalar = 0.06496;
+  constexpr double kSigmoidGrowthRate = -0.6221;
   confidence_ =
       kSigmoidCapacity /
       (1.0 + kSigmoidScalar * std::exp(-kSigmoidGrowthRate * std_dev));
@@ -281,6 +317,7 @@
 }
 
 namespace {
+
 // Hacks to extract a double from a scalar, which is either a ceres jet or a
 // double. Only used for debugging and displaying.
 template <typename S>
@@ -293,6 +330,7 @@
 cv::Point2d ScalarPointToDouble(cv::Point_<S> p) {
   return cv::Point2d(ScalarToDouble(p.x), ScalarToDouble(p.y));
 }
+
 }  // namespace
 
 template <typename S>
@@ -301,20 +339,10 @@
                                  const S *const theta,
                                  const S *const camera_height,
                                  S *residual) const {
-  using Vector3s = Eigen::Matrix<S, 3, 1>;
-  using Affine3s = Eigen::Transform<S, 3, Eigen::Affine>;
+  const auto H_hub_camera = ComputeHubCameraTransform(
+      *roll, *pitch, *yaw, *distance, *theta, *camera_height);
 
-  Eigen::AngleAxis<S> roll_angle(*roll, Vector3s::UnitX());
-  Eigen::AngleAxis<S> pitch_angle(*pitch, Vector3s::UnitY());
-  Eigen::AngleAxis<S> yaw_angle(*yaw, Vector3s::UnitZ());
-  // Construct the rotation and translation of the camera in the hub's frame
-  Eigen::Quaternion<S> R_camera_hub = yaw_angle * pitch_angle * roll_angle;
-  Vector3s T_camera_hub(*distance * ceres::cos(*theta),
-                        *distance * ceres::sin(*theta), *camera_height);
-
-  Affine3s H_camera_hub = Eigen::Translation<S, 3>(T_camera_hub) * R_camera_hub;
-  Affine3s H_hub_camera = H_camera_hub.inverse();
-
+  // Project tape points
   std::vector<cv::Point_<S>> tape_points_proj;
   for (cv::Point3d tape_point_hub : kTapePoints) {
     tape_points_proj.emplace_back(ProjectToImage(tape_point_hub, H_hub_camera));
@@ -332,51 +360,141 @@
         ProjectToImage(*tape_piece_it, H_hub_camera);
   }
 
+  // Now, find the closest tape for each blob.
+  // We don't normally see tape without matching blobs in the center.  So we
+  // want to compress any gaps in the matched tape blobs.  This makes it so it
+  // doesn't want to make the goal super small and skip tape blobs.  The
+  // resulting accuracy is then pretty good.
+
+  // Mapping from tape index to blob index.
+  std::vector<std::pair<size_t, size_t>> tape_indices;
   for (size_t i = 0; i < blob_stats_.size(); i++) {
-    const auto distance = DistanceFromTape(i, tape_points_proj);
+    tape_indices.emplace_back(ClosestTape(i, tape_points_proj), i);
+    VLOG(2) << "Tape indices were " << tape_indices.back().first;
+  }
+
+  std::sort(
+      tape_indices.begin(), tape_indices.end(),
+      [](const std::pair<size_t, size_t> &a,
+         const std::pair<size_t, size_t> &b) { return a.first < b.first; });
+
+  size_t middle_tape_index = 1000;
+  for (size_t i = 0; i < tape_indices.size(); ++i) {
+    if (tape_indices[i].second == middle_blob_index_) {
+      middle_tape_index = i;
+    }
+  }
+  CHECK_NE(middle_tape_index, 1000) << "Failed to find middle tape";
+
+  if (VLOG_IS_ON(2)) {
+    LOG(INFO) << "Middle tape is " << middle_tape_index << ", blob "
+              << middle_blob_index_;
+    for (size_t i = 0; i < tape_indices.size(); ++i) {
+      const auto distance = DistanceFromTapeIndex(
+          tape_indices[i].second, tape_indices[i].first, tape_points_proj);
+      LOG(INFO) << "Blob index " << tape_indices[i].second << " maps to "
+                << tape_indices[i].first << " distance " << distance.x << " "
+                << distance.y;
+    }
+  }
+
+  {
+    size_t offset = 0;
+    for (size_t i = middle_tape_index + 1; i < tape_indices.size(); ++i) {
+      tape_indices[i].first -= offset;
+
+      if (tape_indices[i].first > tape_indices[i - 1].first + 1) {
+        offset += tape_indices[i].first - (tape_indices[i - 1].first + 1);
+        VLOG(2) << "Offset now " << offset;
+        tape_indices[i].first = tape_indices[i - 1].first + 1;
+      }
+    }
+  }
+
+  if (VLOG_IS_ON(2)) {
+    LOG(INFO) << "Middle tape is " << middle_tape_index << ", blob "
+              << middle_blob_index_;
+    for (size_t i = 0; i < tape_indices.size(); ++i) {
+      const auto distance = DistanceFromTapeIndex(
+          tape_indices[i].second, tape_indices[i].first, tape_points_proj);
+      LOG(INFO) << "Blob index " << tape_indices[i].second << " maps to "
+                << tape_indices[i].first << " distance " << distance.x << " "
+                << distance.y;
+    }
+  }
+
+  {
+    size_t offset = 0;
+    for (size_t i = middle_tape_index; i > 0; --i) {
+      tape_indices[i - 1].first -= offset;
+
+      if (tape_indices[i - 1].first + 1 < tape_indices[i].first) {
+        VLOG(2) << "Too big a gap. " << tape_indices[i].first << " and "
+                << tape_indices[i - 1].first;
+
+        offset += tape_indices[i].first - (tape_indices[i - 1].first + 1);
+        tape_indices[i - 1].first = tape_indices[i].first - 1;
+        VLOG(2) << "Offset now " << offset;
+      }
+    }
+  }
+
+  if (VLOG_IS_ON(2)) {
+    LOG(INFO) << "Middle tape is " << middle_tape_index << ", blob "
+              << middle_blob_index_;
+    for (size_t i = 0; i < tape_indices.size(); ++i) {
+      const auto distance = DistanceFromTapeIndex(
+          tape_indices[i].second, tape_indices[i].first, tape_points_proj);
+      LOG(INFO) << "Blob index " << tape_indices[i].second << " maps to "
+                << tape_indices[i].first << " distance " << distance.x << " "
+                << distance.y;
+    }
+  }
+
+  for (size_t i = 0; i < tape_indices.size(); ++i) {
+    const auto distance = DistanceFromTapeIndex(
+        tape_indices[i].second, tape_indices[i].first, tape_points_proj);
+    // Scale the distance based on the blob area: larger blobs have less noise.
+    const S distance_scalar =
+        S(blob_stats_[tape_indices[i].second].area / max_blob_area_);
+    VLOG(2) << "Blob index " << tape_indices[i].second << " maps to "
+            << tape_indices[i].first << " distance " << distance.x << " "
+            << distance.y << " distance scalar "
+            << ScalarToDouble(distance_scalar);
+
     // Set the residual to the (x, y) distance of the centroid from the
-    // nearest projected piece of tape
-    residual[i * 2] = distance.x;
-    residual[(i * 2) + 1] = distance.y;
+    // matched projected piece of tape
+    residual[i * 2] = distance_scalar * distance.x;
+    residual[(i * 2) + 1] = distance_scalar * distance.y;
   }
 
   // Penalize based on the difference between the size of the projected piece of
-  // tape and that of the detected blobs. Use the squared size to avoid taking a
-  // norm, which ceres can't handle well
-  const S middle_tape_piece_width_squared =
-      ceres::pow(middle_tape_piece_points_proj[2].x -
-                     middle_tape_piece_points_proj[3].x,
-                 2) +
-      ceres::pow(middle_tape_piece_points_proj[2].y -
-                     middle_tape_piece_points_proj[3].y,
-                 2);
-  const S middle_tape_piece_height_squared =
-      ceres::pow(middle_tape_piece_points_proj[1].x -
-                     middle_tape_piece_points_proj[2].x,
-                 2) +
-      ceres::pow(middle_tape_piece_points_proj[1].y -
-                     middle_tape_piece_points_proj[2].y,
-                 2);
+  // tape and that of the detected blobs.
+  const S middle_tape_piece_width = ceres::hypot(
+      middle_tape_piece_points_proj[2].x - middle_tape_piece_points_proj[3].x,
+      middle_tape_piece_points_proj[2].y - middle_tape_piece_points_proj[3].y);
+  const S middle_tape_piece_height = ceres::hypot(
+      middle_tape_piece_points_proj[1].x - middle_tape_piece_points_proj[2].x,
+      middle_tape_piece_points_proj[1].y - middle_tape_piece_points_proj[2].y);
 
+  constexpr double kCenterBlobSizeScalar = 0.1;
   residual[blob_stats_.size() * 2] =
-      middle_tape_piece_width_squared -
-      std::pow(blob_stats_[middle_blob_index_].size.width, 2);
+      kCenterBlobSizeScalar *
+      (middle_tape_piece_width -
+       static_cast<S>(blob_stats_[middle_blob_index_].size.width));
   residual[(blob_stats_.size() * 2) + 1] =
-      middle_tape_piece_height_squared -
-      std::pow(blob_stats_[middle_blob_index_].size.height, 2);
+      kCenterBlobSizeScalar *
+      (middle_tape_piece_height -
+       static_cast<S>(blob_stats_[middle_blob_index_].size.height));
 
   if (image_.has_value()) {
     // Draw the current stage of the solving
     cv::Mat image = image_->clone();
-    for (size_t i = 0; i < tape_points_proj.size() - 1; i++) {
-      cv::line(image, ScalarPointToDouble(tape_points_proj[i]),
-               ScalarPointToDouble(tape_points_proj[i + 1]),
-               cv::Scalar(255, 255, 255));
-      cv::circle(image, ScalarPointToDouble(tape_points_proj[i]), 2,
-                 cv::Scalar(255, 20, 147), cv::FILLED);
-      cv::circle(image, ScalarPointToDouble(tape_points_proj[i + 1]), 2,
-                 cv::Scalar(255, 20, 147), cv::FILLED);
+    std::vector<cv::Point2d> tape_points_proj_double;
+    for (auto point : tape_points_proj) {
+      tape_points_proj_double.emplace_back(ScalarPointToDouble(point));
     }
+    DrawProjectedHub(tape_points_proj_double, image);
     cv::imshow("image", image);
     cv::waitKey(10);
   }
@@ -385,9 +503,30 @@
 }
 
 template <typename S>
+Eigen::Transform<S, 3, Eigen::Affine>
+TargetEstimator::ComputeHubCameraTransform(S roll, S pitch, S yaw, S distance,
+                                           S theta, S camera_height) const {
+  using Vector3s = Eigen::Matrix<S, 3, 1>;
+  using Affine3s = Eigen::Transform<S, 3, Eigen::Affine>;
+
+  Eigen::AngleAxis<S> roll_angle(roll, Vector3s::UnitX());
+  Eigen::AngleAxis<S> pitch_angle(pitch, Vector3s::UnitY());
+  Eigen::AngleAxis<S> yaw_angle(yaw, Vector3s::UnitZ());
+  // Construct the rotation and translation of the camera in the hub's frame
+  Eigen::Quaternion<S> R_camera_hub = yaw_angle * pitch_angle * roll_angle;
+  Vector3s T_camera_hub(distance * ceres::cos(theta),
+                        distance * ceres::sin(theta), camera_height);
+
+  Affine3s H_camera_hub = Eigen::Translation<S, 3>(T_camera_hub) * R_camera_hub;
+  Affine3s H_hub_camera = H_camera_hub.inverse();
+
+  return H_hub_camera;
+}
+
+template <typename S>
 cv::Point_<S> TargetEstimator::ProjectToImage(
     cv::Point3d tape_point_hub,
-    Eigen::Transform<S, 3, Eigen::Affine> &H_hub_camera) const {
+    const Eigen::Transform<S, 3, Eigen::Affine> &H_hub_camera) const {
   using Vector3s = Eigen::Matrix<S, 3, 1>;
 
   const Vector3s tape_point_hub_eigen =
@@ -416,33 +555,70 @@
 }  // namespace
 
 template <typename S>
-cv::Point_<S> TargetEstimator::DistanceFromTape(
+cv::Point_<S> TargetEstimator::DistanceFromTapeIndex(
+    size_t blob_index, size_t tape_index,
+    const std::vector<cv::Point_<S>> &tape_points) const {
+  return Distance(blob_stats_[blob_index].centroid, tape_points[tape_index]);
+}
+
+template <typename S>
+size_t TargetEstimator::ClosestTape(
     size_t blob_index, const std::vector<cv::Point_<S>> &tape_points) const {
   auto distance = cv::Point_<S>(std::numeric_limits<S>::infinity(),
                                 std::numeric_limits<S>::infinity());
+  size_t final_match = 255;
   if (blob_index == middle_blob_index_) {
     // Fix the middle blob so the solver can't go too far off
-    distance = Distance(blob_stats_[middle_blob_index_].centroid,
-                        tape_points[tape_points.size() / 2]);
+    final_match = tape_points.size() / 2;
+    distance = DistanceFromTapeIndex(blob_index, final_match, tape_points);
   } else {
     // Give the other blob_stats some freedom in case some are split into pieces
     for (auto it = tape_points.begin(); it < tape_points.end(); it++) {
+      const size_t tape_index = std::distance(tape_points.begin(), it);
       const auto current_distance =
-          Distance(blob_stats_[blob_index].centroid, *it);
-      if ((it != tape_points.begin() + (tape_points.size() / 2)) &&
+          DistanceFromTapeIndex(blob_index, tape_index, tape_points);
+      if ((tape_index != (tape_points.size() / 2)) &&
           Less(current_distance, distance)) {
+        final_match = tape_index;
         distance = current_distance;
       }
     }
   }
 
-  return distance;
+  VLOG(2) << "Matched index " << blob_index << " to " << final_match
+          << " distance " << distance.x << " " << distance.y;
+  CHECK_NE(final_match, 255);
+
+  return final_match;
 }
 
-namespace {
-void DrawEstimateValues(double distance, double angle_to_target,
-                        double angle_to_camera, double roll, double pitch,
-                        double yaw, double confidence, cv::Mat view_image) {
+void TargetEstimator::DrawProjectedHub(
+    const std::vector<cv::Point2d> &tape_points_proj,
+    cv::Mat view_image) const {
+  for (size_t i = 0; i < tape_points_proj.size() - 1; i++) {
+    cv::line(view_image, ScalarPointToDouble(tape_points_proj[i]),
+             ScalarPointToDouble(tape_points_proj[i + 1]),
+             cv::Scalar(255, 255, 255));
+    cv::circle(view_image, ScalarPointToDouble(tape_points_proj[i]), 2,
+               cv::Scalar(255, 20, 147), cv::FILLED);
+    cv::circle(view_image, ScalarPointToDouble(tape_points_proj[i + 1]), 2,
+               cv::Scalar(255, 20, 147), cv::FILLED);
+  }
+}
+
+void TargetEstimator::DrawEstimate(cv::Mat view_image) const {
+  if (FLAGS_draw_projected_hub) {
+    // Draw projected hub
+    const auto H_hub_camera = ComputeHubCameraTransform(
+        roll_, pitch_, yaw_, distance_, angle_to_camera_, camera_height_);
+    std::vector<cv::Point2d> tape_points_proj;
+    for (cv::Point3d tape_point_hub : kTapePoints) {
+      tape_points_proj.emplace_back(
+          ProjectToImage(tape_point_hub, H_hub_camera));
+    }
+    DrawProjectedHub(tape_points_proj, view_image);
+  }
+
   constexpr int kTextX = 10;
   int text_y = 0;
   constexpr int kTextSpacing = 25;
@@ -450,44 +626,29 @@
   const auto kTextColor = cv::Scalar(0, 255, 255);
   constexpr double kFontScale = 0.6;
 
-  cv::putText(view_image, absl::StrFormat("Distance: %.3f", distance),
+  cv::putText(view_image,
+              absl::StrFormat("Distance: %.3f m (%.3f in)", distance_,
+                              distance_ / 0.0254),
               cv::Point(kTextX, text_y += kTextSpacing),
               cv::FONT_HERSHEY_DUPLEX, kFontScale, kTextColor, 2);
   cv::putText(view_image,
-              absl::StrFormat("Angle to target: %.3f", angle_to_target),
+              absl::StrFormat("Angle to target: %.3f", angle_to_target()),
               cv::Point(kTextX, text_y += kTextSpacing),
               cv::FONT_HERSHEY_DUPLEX, kFontScale, kTextColor, 2);
   cv::putText(view_image,
-              absl::StrFormat("Angle to camera: %.3f", angle_to_camera),
+              absl::StrFormat("Angle to camera: %.3f", angle_to_camera_),
               cv::Point(kTextX, text_y += kTextSpacing),
               cv::FONT_HERSHEY_DUPLEX, kFontScale, kTextColor, 2);
 
-  cv::putText(
-      view_image,
-      absl::StrFormat("Roll: %.3f, pitch: %.3f, yaw: %.3f", roll, pitch, yaw),
-      cv::Point(kTextX, text_y += kTextSpacing), cv::FONT_HERSHEY_DUPLEX,
-      kFontScale, kTextColor, 2);
-
-  cv::putText(view_image, absl::StrFormat("Confidence: %.3f", confidence),
+  cv::putText(view_image,
+              absl::StrFormat("Roll: %.3f, pitch: %.3f, yaw: %.3f", roll_,
+                              pitch_, yaw_),
               cv::Point(kTextX, text_y += kTextSpacing),
               cv::FONT_HERSHEY_DUPLEX, kFontScale, kTextColor, 2);
-}
-}  // namespace
 
-void TargetEstimator::DrawEstimate(const TargetEstimate &target_estimate,
-                                   cv::Mat view_image) {
-  DrawEstimateValues(target_estimate.distance(),
-                     target_estimate.angle_to_target(),
-                     target_estimate.angle_to_camera(),
-                     target_estimate.rotation_camera_hub()->roll(),
-                     target_estimate.rotation_camera_hub()->pitch(),
-                     target_estimate.rotation_camera_hub()->yaw(),
-                     target_estimate.confidence(), view_image);
-}
-
-void TargetEstimator::DrawEstimate(cv::Mat view_image) const {
-  DrawEstimateValues(distance_, angle_to_target(), angle_to_camera_, roll_,
-                     pitch_, yaw_, confidence_, view_image);
+  cv::putText(view_image, absl::StrFormat("Confidence: %.3f", confidence_),
+              cv::Point(kTextX, text_y += kTextSpacing),
+              cv::FONT_HERSHEY_DUPLEX, kFontScale, kTextColor, 2);
 }
 
 }  // namespace y2022::vision
diff --git a/y2022/vision/target_estimator.h b/y2022/vision/target_estimator.h
index b509a2e..ac170e8 100644
--- a/y2022/vision/target_estimator.h
+++ b/y2022/vision/target_estimator.h
@@ -47,9 +47,7 @@
 
   inline double confidence() const { return confidence_; }
 
-  // Draws the distance, angle, and rotation on the given image
-  static void DrawEstimate(const TargetEstimate &target_estimate,
-                           cv::Mat view_image);
+  // Draws the distance, angle, rotation, and projected tape on the given image
   void DrawEstimate(cv::Mat view_image) const;
 
  private:
@@ -59,18 +57,31 @@
   // clockwise around the rectangle
   static const std::array<cv::Point3d, 4> kMiddleTapePiecePoints;
 
+  // Computes matrix of hub in camera's frame
+  template <typename S>
+  Eigen::Transform<S, 3, Eigen::Affine> ComputeHubCameraTransform(
+      S roll, S pitch, S yaw, S distance, S theta, S camera_height) const;
+
   template <typename S>
   cv::Point_<S> ProjectToImage(
       cv::Point3d tape_point_hub,
-      Eigen::Transform<S, 3, Eigen::Affine> &H_hub_camera) const;
+      const Eigen::Transform<S, 3, Eigen::Affine> &H_hub_camera) const;
 
   template <typename S>
-  cv::Point_<S> DistanceFromTape(
-      size_t centroid_index,
+  size_t ClosestTape(size_t centroid_index,
+                     const std::vector<cv::Point_<S>> &tape_points) const;
+
+  template <typename S>
+  cv::Point_<S> DistanceFromTapeIndex(
+      size_t centroid_index, size_t tape_index,
       const std::vector<cv::Point_<S>> &tape_points) const;
 
+  void DrawProjectedHub(const std::vector<cv::Point2d> &tape_points_proj,
+                        cv::Mat view_image) const;
+
   std::vector<BlobDetector::BlobStats> blob_stats_;
   size_t middle_blob_index_;
+  double max_blob_area_;
   std::optional<cv::Mat> image_;
 
   Eigen::Matrix3d intrinsics_;
diff --git a/y2022/vision/test_ball_color_image.jpg b/y2022/vision/test_ball_color_image.jpg
new file mode 100644
index 0000000..8750460
--- /dev/null
+++ b/y2022/vision/test_ball_color_image.jpg
Binary files differ
diff --git a/y2022/vision/viewer.cc b/y2022/vision/viewer.cc
index 7c35ce9..446f1f6 100644
--- a/y2022/vision/viewer.cc
+++ b/y2022/vision/viewer.cc
@@ -6,6 +6,7 @@
 #include <opencv2/imgproc.hpp>
 #include <random>
 
+#include "absl/strings/str_format.h"
 #include "aos/events/shm_event_loop.h"
 #include "aos/init.h"
 #include "aos/time/time.h"
@@ -20,6 +21,7 @@
 DEFINE_string(channel, "/camera", "Channel name for the image.");
 DEFINE_string(config, "aos_config.json", "Path to the config file to use.");
 DEFINE_string(png_dir, "", "Path to a set of images to display.");
+DEFINE_string(png_pattern, "*", R"(Pattern to match pngs using '*'/'?'.)");
 DEFINE_string(calibration_node, "",
               "If reading locally, use the calibration for this node");
 DEFINE_int32(
@@ -196,7 +198,8 @@
 
 void ViewerLocal() {
   std::vector<cv::String> file_list;
-  cv::glob(FLAGS_png_dir + "/*.png", file_list, false);
+  cv::glob(absl::StrFormat("%s/%s.png", FLAGS_png_dir, FLAGS_png_pattern),
+           file_list, false);
 
   // Sort the images by timestamp
   if (FLAGS_sort_by_time) {
@@ -224,9 +227,10 @@
                      << FLAGS_calibration_node << "\" with team number "
                      << FLAGS_calibration_team_number;
 
-  auto intrinsics_float = cv::Mat(3, 3, CV_32F,
-                                  const_cast<void *>(static_cast<const void *>(
-                                      calibration->intrinsics()->data())));
+  const auto intrinsics_float = cv::Mat(
+      3, 3, CV_32F,
+      const_cast<void *>(
+          static_cast<const void *>(calibration->intrinsics()->data())));
   cv::Mat intrinsics;
   intrinsics_float.convertTo(intrinsics, CV_64F);
 
@@ -240,11 +244,21 @@
   cv::Mat extrinsics;
   extrinsics_float.convertTo(extrinsics, CV_64F);
 
+  const auto dist_coeffs_float = cv::Mat(
+      5, 1, CV_32F,
+      const_cast<void *>(
+          static_cast<const void *>(calibration->dist_coeffs()->data())));
+  cv::Mat dist_coeffs;
+  dist_coeffs_float.convertTo(dist_coeffs, CV_64F);
+
   TargetEstimator estimator(intrinsics, extrinsics);
 
   for (auto it = file_list.begin() + FLAGS_skip; it < file_list.end(); it++) {
     LOG(INFO) << "Reading file " << (it - file_list.begin()) << ": " << *it;
-    cv::Mat image_mat = cv::imread(it->c_str());
+    cv::Mat image_mat_distorted = cv::imread(it->c_str());
+    cv::Mat image_mat;
+    cv::undistort(image_mat_distorted, image_mat, intrinsics, dist_coeffs);
+
     BlobDetector::BlobResult blob_result;
     blob_result.binarized_image =
         cv::Mat::zeros(cv::Size(image_mat.cols, image_mat.rows), CV_8UC1);
@@ -260,11 +274,12 @@
                      blob_result.filtered_blobs.size()
               << ")";
 
+    estimator.Solve(blob_result.filtered_stats,
+                    FLAGS_display_estimation ? std::make_optional(ret_image)
+                                             : std::nullopt);
     if (blob_result.filtered_blobs.size() > 0) {
-      estimator.Solve(blob_result.filtered_stats,
-                      FLAGS_display_estimation ? std::make_optional(ret_image)
-                                               : std::nullopt);
       estimator.DrawEstimate(ret_image);
+      LOG(INFO) << "Read file " << (it - file_list.begin()) << ": " << *it;
     }
 
     cv::imshow("image", image_mat);
diff --git a/y2022/vision/vision_plotter.ts b/y2022/vision/vision_plotter.ts
index 8b9fa7f..adbf900 100644
--- a/y2022/vision/vision_plotter.ts
+++ b/y2022/vision/vision_plotter.ts
@@ -4,7 +4,7 @@
 import {BLUE, BROWN, CYAN, GREEN, PINK, RED, WHITE} from 'org_frc971/aos/network/www/colors';
 import {Connection} from 'org_frc971/aos/network/www/proxy';
 import {Table} from 'org_frc971/aos/network/www/reflection';
-import {Schema} from 'org_frc971/external/com_github_google_flatbuffers/reflection/reflection_generated';
+import {Schema} from 'flatbuffers_reflection/reflection_generated';
 import {TargetEstimate} from 'org_frc971/y2022/vision/target_estimate_generated';
 
 
diff --git a/y2022/wpilib_interface.cc b/y2022/wpilib_interface.cc
index b1f386c..84164bb 100644
--- a/y2022/wpilib_interface.cc
+++ b/y2022/wpilib_interface.cc
@@ -17,6 +17,7 @@
 #include "frc971/wpilib/ahal/DigitalGlitchFilter.h"
 #include "frc971/wpilib/ahal/DriverStation.h"
 #include "frc971/wpilib/ahal/Encoder.h"
+#include "frc971/wpilib/ahal/Servo.h"
 #include "frc971/wpilib/ahal/TalonFX.h"
 #include "frc971/wpilib/ahal/VictorSP.h"
 #undef ERROR
@@ -61,6 +62,8 @@
 namespace chrono = ::std::chrono;
 using std::make_unique;
 
+DEFINE_bool(can_catapult, false, "If true, use CAN to control the catapult.");
+
 namespace y2022 {
 namespace wpilib {
 namespace {
@@ -178,8 +181,15 @@
     imu_yaw_rate_input_ = ::std::move(sensor);
     imu_yaw_rate_reader_.set_input(imu_yaw_rate_input_.get());
   }
+  void set_catapult_falcon_1(
+      ::std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t1,
+      ::std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t2) {
+    catapult_falcon_1_can_ = ::std::move(t1);
+    catapult_falcon_2_can_ = ::std::move(t2);
+  }
 
   void RunIteration() override {
+    superstructure_reading_->Set(true);
     {
       auto builder = superstructure_position_sender_.MakeBuilder();
 
@@ -342,6 +352,13 @@
     flipper_arm_right_potentiometer_ = ::std::move(potentiometer);
   }
 
+  std::shared_ptr<frc::DigitalOutput> superstructure_reading_;
+
+  void set_superstructure_reading(
+      std::shared_ptr<frc::DigitalOutput> superstructure_reading) {
+    superstructure_reading_ = superstructure_reading;
+  }
+
   void set_intake_encoder_front(::std::unique_ptr<frc::Encoder> encoder) {
     fast_encoder_filter_.Add(encoder.get());
     intake_encoder_front_.set_encoder(::std::move(encoder));
@@ -418,6 +435,9 @@
       intake_encoder_back_, turret_encoder_, catapult_encoder_;
 
   frc971::wpilib::DMAPulseWidthReader imu_heading_reader_, imu_yaw_rate_reader_;
+
+  ::std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX>
+      catapult_falcon_1_can_, catapult_falcon_2_can_;
 };
 
 class SuperstructureWriter
@@ -425,7 +445,15 @@
  public:
   SuperstructureWriter(aos::EventLoop *event_loop)
       : frc971::wpilib::LoopOutputHandler<superstructure::Output>(
-            event_loop, "/superstructure") {}
+            event_loop, "/superstructure"),
+        catapult_reversal_(make_unique<frc::DigitalOutput>(0)) {}
+
+  void set_climber_servo_left(::std::unique_ptr<::frc::Servo> t) {
+    climber_servo_left_ = ::std::move(t);
+  }
+  void set_climber_servo_right(::std::unique_ptr<::frc::Servo> t) {
+    climber_servo_right_ = ::std::move(t);
+  }
 
   void set_climber_falcon(std::unique_ptr<frc::TalonFX> t) {
     climber_falcon_ = std::move(t);
@@ -440,8 +468,8 @@
   }
 
   void set_catapult_falcon_1(
-      ::std::unique_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t1,
-      ::std::unique_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t2) {
+      ::std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t1,
+      ::std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> t2) {
     catapult_falcon_1_can_ = ::std::move(t1);
     catapult_falcon_2_can_ = ::std::move(t2);
 
@@ -452,12 +480,16 @@
       falcon->ConfigStatorCurrentLimit(
           {false, Values::kIntakeRollerStatorCurrentLimit(),
            Values::kIntakeRollerStatorCurrentLimit(), 0});
-      falcon->SetStatusFramePeriod(ctre::phoenix::motorcontrol::Status_1_General, 5);
-      falcon->SetControlFramePeriod(ctre::phoenix::motorcontrol::Control_3_General, 5);
+      falcon->SetStatusFramePeriod(
+          ctre::phoenix::motorcontrol::Status_1_General, 1);
+      falcon->SetControlFramePeriod(
+          ctre::phoenix::motorcontrol::Control_3_General, 1);
+      falcon->SetStatusFramePeriod(
+          ctre::phoenix::motorcontrol::Status_Brushless_Current, 50);
+      falcon->ConfigOpenloopRamp(0.0);
+      falcon->ConfigClosedloopRamp(0.0);
+      falcon->ConfigVoltageMeasurementFilter(1);
     }
-    catapult_falcon_2_can_->Follow(
-        *catapult_falcon_1_can_,
-        ctre::phoenix::motorcontrol::FollowerType_PercentOutput);
   }
 
   void set_intake_falcon_front(::std::unique_ptr<frc::TalonFX> t) {
@@ -506,18 +538,24 @@
     return flipper_arms_falcon_;
   }
 
-  void set_transfer_roller_victor_front(::std::unique_ptr<::frc::VictorSP> t) {
-    transfer_roller_victor_front_ = ::std::move(t);
+  void set_transfer_roller_victor(::std::unique_ptr<::frc::VictorSP> t) {
+    transfer_roller_victor_ = ::std::move(t);
   }
 
-  void set_transfer_roller_victor_back(::std::unique_ptr<::frc::VictorSP> t) {
-    transfer_roller_victor_back_ = ::std::move(t);
+  std::shared_ptr<frc::DigitalOutput> superstructure_reading_;
+
+  void set_superstructure_reading(
+      std::shared_ptr<frc::DigitalOutput> superstructure_reading) {
+    superstructure_reading_ = superstructure_reading;
   }
 
  private:
   void Stop() override {
     AOS_LOG(WARNING, "Superstructure output too old.\n");
     climber_falcon_->SetDisabled();
+    climber_servo_left_->SetRaw(0);
+    climber_servo_right_->SetRaw(0);
+
     roller_falcon_front_->Set(
         ctre::phoenix::motorcontrol::ControlMode::Disabled, 0);
     roller_falcon_back_->Set(ctre::phoenix::motorcontrol::ControlMode::Disabled,
@@ -526,37 +564,44 @@
         ctre::phoenix::motorcontrol::ControlMode::Disabled, 0);
     intake_falcon_front_->SetDisabled();
     intake_falcon_back_->SetDisabled();
-    transfer_roller_victor_front_->SetDisabled();
-    transfer_roller_victor_back_->SetDisabled();
+    transfer_roller_victor_->SetDisabled();
     if (catapult_falcon_1_) {
       catapult_falcon_1_->SetDisabled();
     }
     if (catapult_falcon_1_can_) {
       catapult_falcon_1_can_->Set(
           ctre::phoenix::motorcontrol::ControlMode::Disabled, 0);
+      catapult_falcon_2_can_->Set(
+          ctre::phoenix::motorcontrol::ControlMode::Disabled, 0);
     }
     turret_falcon_->SetDisabled();
   }
 
   void Write(const superstructure::Output &output) override {
     WritePwm(-output.climber_voltage(), climber_falcon_.get());
+    climber_servo_left_->SetPosition(output.climber_servo_left());
+    climber_servo_right_->SetPosition(output.climber_servo_right());
 
     WritePwm(output.intake_voltage_front(), intake_falcon_front_.get());
     WritePwm(output.intake_voltage_back(), intake_falcon_back_.get());
     WriteCan(output.roller_voltage_front(), roller_falcon_front_.get());
     WriteCan(output.roller_voltage_back(), roller_falcon_back_.get());
-    WritePwm(output.transfer_roller_voltage_front(),
-             transfer_roller_victor_front_.get());
-    WritePwm(-output.transfer_roller_voltage_back(),
-             transfer_roller_victor_back_.get());
+    WritePwm(output.transfer_roller_voltage(), transfer_roller_victor_.get());
 
     WriteCan(-output.flipper_arms_voltage(), flipper_arms_falcon_.get());
 
     if (catapult_falcon_1_) {
       WritePwm(output.catapult_voltage(), catapult_falcon_1_.get());
+      superstructure_reading_->Set(false);
+      if (output.catapult_voltage() > 0) {
+        catapult_reversal_->Set(true);
+      } else {
+        catapult_reversal_->Set(false);
+      }
     }
     if (catapult_falcon_1_can_) {
       WriteCan(output.catapult_voltage(), catapult_falcon_1_can_.get());
+      WriteCan(output.catapult_voltage(), catapult_falcon_2_can_.get());
     }
 
     WritePwm(-output.turret_voltage(), turret_falcon_.get());
@@ -588,8 +633,11 @@
 
   ::std::unique_ptr<::frc::TalonFX> turret_falcon_, catapult_falcon_1_,
       climber_falcon_;
-  ::std::unique_ptr<::frc::VictorSP> transfer_roller_victor_front_,
-      transfer_roller_victor_back_;
+  ::std::unique_ptr<::frc::VictorSP> transfer_roller_victor_;
+
+  std::unique_ptr<frc::DigitalOutput> catapult_reversal_;
+
+  ::std::unique_ptr<::frc::Servo> climber_servo_left_, climber_servo_right_;
 };
 
 class CANSensorReader {
@@ -661,11 +709,16 @@
     ::frc971::wpilib::PDPFetcher pdp_fetcher(&pdp_fetcher_event_loop);
     AddLoop(&pdp_fetcher_event_loop);
 
+    std::shared_ptr<frc::DigitalOutput> superstructure_reading =
+        make_unique<frc::DigitalOutput>(25);
+
     // Thread 3.
     ::aos::ShmEventLoop sensor_reader_event_loop(&config.message());
     SensorReader sensor_reader(&sensor_reader_event_loop, values);
+    sensor_reader.set_pwm_trigger(true);
     sensor_reader.set_drivetrain_left_encoder(make_encoder(1));
     sensor_reader.set_drivetrain_right_encoder(make_encoder(0));
+    sensor_reader.set_superstructure_reading(superstructure_reading);
 
     sensor_reader.set_intake_encoder_front(make_encoder(3));
     sensor_reader.set_intake_front_absolute_pwm(
@@ -723,18 +776,30 @@
     superstructure_writer.set_roller_falcon_back(
         make_unique<::ctre::phoenix::motorcontrol::can::TalonFX>(1));
 
-    superstructure_writer.set_transfer_roller_victor_front(
-        make_unique<::frc::VictorSP>(6));
-    superstructure_writer.set_transfer_roller_victor_back(
+    superstructure_writer.set_transfer_roller_victor(
         make_unique<::frc::VictorSP>(5));
 
     superstructure_writer.set_intake_falcon_front(make_unique<frc::TalonFX>(2));
     superstructure_writer.set_intake_falcon_back(make_unique<frc::TalonFX>(4));
     superstructure_writer.set_climber_falcon(make_unique<frc::TalonFX>(8));
+    superstructure_writer.set_climber_servo_left(make_unique<frc::Servo>(7));
+    superstructure_writer.set_climber_servo_right(make_unique<frc::Servo>(6));
     superstructure_writer.set_flipper_arms_falcon(
         make_unique<::ctre::phoenix::motorcontrol::can::TalonFX>(2));
+    superstructure_writer.set_superstructure_reading(superstructure_reading);
 
-    superstructure_writer.set_catapult_falcon_1(make_unique<frc::TalonFX>(9));
+    if (!FLAGS_can_catapult) {
+      superstructure_writer.set_catapult_falcon_1(make_unique<frc::TalonFX>(9));
+    } else {
+      std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> catapult1 =
+          make_unique<::ctre::phoenix::motorcontrol::can::TalonFX>(3,
+                                                                   "Catapult");
+      std::shared_ptr<::ctre::phoenix::motorcontrol::can::TalonFX> catapult2 =
+          make_unique<::ctre::phoenix::motorcontrol::can::TalonFX>(4,
+                                                                   "Catapult");
+      superstructure_writer.set_catapult_falcon_1(catapult1, catapult2);
+      sensor_reader.set_catapult_falcon_1(catapult1, catapult2);
+    }
 
     AddLoop(&output_event_loop);
 
diff --git a/y2022/www/field_handler.ts b/y2022/www/field_handler.ts
index 63e73c7..22989be 100644
--- a/y2022/www/field_handler.ts
+++ b/y2022/www/field_handler.ts
@@ -97,7 +97,9 @@
     }
 
     this.connection.addConfigHandler(() => {
-      this.connection.addHandler(
+      // Visualization message is reliable so that we can see *all* the vision
+      // matches.
+      this.connection.addReliableHandler(
           '/localizer', LocalizerVisualization.getFullyQualifiedName(),
           (data) => {
             this.handleLocalizerDebug(data);
@@ -278,37 +280,13 @@
 
     // Draw the matches with debugging information from the localizer.
     const now = Date.now() / 1000.0;
-    for (const [time, value] of this.localizerImageMatches) {
-      const age = now - time;
-      const kRemovalAge = 2.0;
-      if (age > kRemovalAge) {
-        this.localizerImageMatches.delete(time);
-        continue;
-      }
-      const ageAlpha = (kRemovalAge - age) / kRemovalAge
-      for (let i = 0; i < value.targetsLength(); i++) {
-        const imageDebug = value.targets(i);
-        const x = imageDebug.impliedRobotX();
-        const y = imageDebug.impliedRobotY();
-        const theta = imageDebug.impliedRobotTheta();
-        const cameraX = imageDebug.cameraX();
-        const cameraY = imageDebug.cameraY();
-        const cameraTheta = imageDebug.cameraTheta();
-        const accepted = imageDebug.accepted();
-        // Make camera readings fade over time.
-        const alpha = Math.round(255 * ageAlpha).toString(16).padStart(2, '0');
-        const dashed = false;
-        const acceptedRgb = accepted ? '#00FF00' : '#FF0000';
-        const acceptedRgba = acceptedRgb + alpha;
-        const cameraRgb = PI_COLORS[imageDebug.camera()];
-        const cameraRgba = cameraRgb + alpha;
-        this.drawRobot(x, y, theta, null, acceptedRgba, dashed, false);
-        this.drawCamera(cameraX, cameraY, cameraTheta, cameraRgba, false);
-      }
-    }
     if (this.superstructureStatus) {
       this.shotDistance.innerHTML = this.superstructureStatus.aimer() ?
-          this.superstructureStatus.aimer().shotDistance().toFixed(2) :
+          (this.superstructureStatus.aimer().shotDistance() /
+           0.0254).toFixed(2) +
+              'in, ' +
+              this.superstructureStatus.aimer().shotDistance().toFixed(2) +
+              'm' :
           'NA';
 
       this.fire.innerHTML = this.superstructureStatus.fire() ? 'true' : 'false';
@@ -418,6 +396,36 @@
               null);
     }
 
+    for (const [time, value] of this.localizerImageMatches) {
+      const age = now - time;
+      const kRemovalAge = 1.0;
+      if (age > kRemovalAge) {
+        this.localizerImageMatches.delete(time);
+        continue;
+      }
+      const kMaxImageAlpha = 0.5;
+      const ageAlpha = kMaxImageAlpha * (kRemovalAge - age) / kRemovalAge
+      for (let i = 0; i < value.targetsLength(); i++) {
+        const imageDebug = value.targets(i);
+        const x = imageDebug.impliedRobotX();
+        const y = imageDebug.impliedRobotY();
+        const theta = imageDebug.impliedRobotTheta();
+        const cameraX = imageDebug.cameraX();
+        const cameraY = imageDebug.cameraY();
+        const cameraTheta = imageDebug.cameraTheta();
+        const accepted = imageDebug.accepted();
+        // Make camera readings fade over time.
+        const alpha = Math.round(255 * ageAlpha).toString(16).padStart(2, '0');
+        const dashed = false;
+        const acceptedRgb = accepted ? '#00FF00' : '#FF0000';
+        const acceptedRgba = acceptedRgb + alpha;
+        const cameraRgb = PI_COLORS[imageDebug.camera()];
+        const cameraRgba = cameraRgb + alpha;
+        this.drawRobot(x, y, theta, null, acceptedRgba, dashed, false);
+        this.drawCamera(cameraX, cameraY, cameraTheta, cameraRgba, false);
+      }
+    }
+
     window.requestAnimationFrame(() => this.draw());
   }
 
diff --git a/y2022/y2022_imu.json b/y2022/y2022_imu.json
index 06a7955..0e61210 100644
--- a/y2022/y2022_imu.json
+++ b/y2022/y2022_imu.json
@@ -19,41 +19,95 @@
       "name": "/imu/aos",
       "type": "aos.starter.Status",
       "source_node": "imu",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
       "frequency": 50,
       "num_senders": 20,
+      "logger_nodes": [
+        "roborio",
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "roborio",
           "priority": 5,
-          "time_to_live": 5000000
+          "time_to_live": 5000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "imu"
+          ]
         },
         {
           "name": "logger",
           "priority": 5,
-          "time_to_live": 5000000
+          "time_to_live": 5000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "imu"
+          ]
         }
       ]
     },
     {
+      "name": "/imu/aos/remote_timestamps/roborio/imu/aos/aos-starter-Status",
+      "type": "aos.message_bridge.RemoteMessage",
+      "frequency": 100,
+      "source_node": "imu",
+      "max_size": 208
+    },
+    {
+      "name": "/imu/aos/remote_timestamps/logger/imu/aos/aos-starter-Status",
+      "type": "aos.message_bridge.RemoteMessage",
+      "frequency": 100,
+      "source_node": "imu",
+      "max_size": 208
+    },
+    {
       "name": "/imu/aos",
       "type": "aos.starter.StarterRpc",
       "source_node": "imu",
       "frequency": 10,
       "num_senders": 2,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "roborio",
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "roborio",
           "priority": 5,
-          "time_to_live": 5000000
+          "time_to_live": 5000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "imu"
+          ]
         },
         {
           "name": "logger",
           "priority": 5,
-          "time_to_live": 5000000
+          "time_to_live": 5000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "imu"
+          ]
         }
       ]
     },
     {
+      "name": "/imu/aos/remote_timestamps/roborio/imu/aos/aos-starter-StarterRpc",
+      "type": "aos.message_bridge.RemoteMessage",
+      "frequency": 20,
+      "source_node": "imu",
+      "max_size": 208
+    },
+    {
+      "name": "/imu/aos/remote_timestamps/logger/imu/aos/aos-starter-StarterRpc",
+      "type": "aos.message_bridge.RemoteMessage",
+      "frequency": 20,
+      "source_node": "imu",
+      "max_size": 208
+    },
+    {
       "name": "/imu/aos",
       "type": "aos.message_bridge.ServerStatistics",
       "source_node": "imu",
@@ -64,7 +118,7 @@
       "name": "/imu/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "imu",
-      "frequency": 10,
+      "frequency": 20,
       "num_senders": 2
     },
     {
@@ -118,6 +172,10 @@
       "name": "/logger/aos",
       "type": "aos.starter.StarterRpc",
       "source_node": "logger",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "imu"
+      ],
       "destination_nodes": [
         {
           "name": "imu",
@@ -143,6 +201,10 @@
       "name": "/logger/aos",
       "type": "aos.starter.Status",
       "source_node": "logger",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "imu"
+      ],
       "destination_nodes": [
         {
           "name": "imu",
@@ -168,6 +230,10 @@
       "name": "/roborio/aos",
       "type": "aos.starter.StarterRpc",
       "source_node": "roborio",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "imu"
+      ],
       "destination_nodes": [
         {
           "name": "imu",
@@ -226,50 +292,17 @@
       "max_size": 2000
     },
     {
-      "name": "/imu/aos/remote_timestamps/logger/localizer/frc971-controls-LocalizerStatus",
-      "type": "aos.message_bridge.RemoteMessage",
-      "source_node": "imu",
-      "logger": "NOT_LOGGED",
-      "frequency": 2200,
-      "num_senders": 2,
-      "max_size": 200
-    },
-    {
       "name": "/localizer",
       "type": "frc971.controls.LocalizerVisualization",
       "source_node": "imu",
       "frequency": 200,
-      "max_size": 2000,
-      "logger": "LOCAL_AND_REMOTE_LOGGER",
-      "logger_nodes": [
-        "logger"
-      ],
-      "destination_nodes": [
-        {
-          "name": "logger",
-          "priority": 5,
-          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
-          "timestamp_logger_nodes": [
-            "imu"
-          ],
-          "time_to_live": 5000000
-        }
-      ]
-    },
-    {
-      "name": "/imu/aos/remote_timestamps/logger/localizer/frc971-controls-LocalizerVisualization",
-      "type": "aos.message_bridge.RemoteMessage",
-      "source_node": "imu",
-      "logger": "NOT_LOGGED",
-      "frequency": 200,
-      "num_senders": 2,
-      "max_size": 200
+      "max_size": 2000
     },
     {
       "name": "/localizer",
       "type": "frc971.controls.LocalizerOutput",
       "source_node": "imu",
-      "frequency": 200,
+      "frequency": 400,
       "max_size": 200,
       "logger": "LOCAL_AND_REMOTE_LOGGER",
       "logger_nodes": [
@@ -302,7 +335,7 @@
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "imu",
       "logger": "NOT_LOGGED",
-      "frequency": 200,
+      "frequency": 400,
       "num_senders": 2,
       "max_size": 200
     },
@@ -321,31 +354,7 @@
       "source_node": "imu",
       "frequency": 2200,
       "max_size": 1600,
-      "num_senders": 2,
-      "logger": "LOCAL_AND_REMOTE_LOGGER",
-      "logger_nodes": [
-        "logger"
-      ],
-      "destination_nodes": [
-        {
-          "name": "logger",
-          "priority": 5,
-          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
-          "timestamp_logger_nodes": [
-            "imu"
-          ],
-          "time_to_live": 5000000
-        }
-      ]
-    },
-    {
-      "name": "/imu/aos/remote_timestamps/logger/localizer/frc971-IMUValuesBatch",
-      "type": "aos.message_bridge.RemoteMessage",
-      "source_node": "imu",
-      "logger": "NOT_LOGGED",
-      "frequency": 2200,
-      "num_senders": 2,
-      "max_size": 200
+      "num_senders": 2
     }
   ],
   "applications": [
diff --git a/y2022/y2022_logger.json b/y2022/y2022_logger.json
index df1d56e..f54ccd7 100644
--- a/y2022/y2022_logger.json
+++ b/y2022/y2022_logger.json
@@ -19,6 +19,38 @@
       ]
    },
     {
+      "name": "/superstructure",
+      "type": "y2022.vision.BallColor",
+      "source_node": "logger",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "roborio"
+      ],
+      "frequency": 200,
+      "num_senders": 2,
+      "max_size": 72,
+      "destination_nodes": [
+        {
+          "name": "roborio",
+          "priority": 2,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ],
+          "time_to_live": 5000000
+        }
+      ]
+    },
+    {
+      "name": "/aos/remote_timestamps/roborio/superstructure/y2022-vision-BallColor",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "logger",
+      "logger": "NOT_LOGGED",
+      "frequency": 20,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
       "name": "/drivetrain",
       "type": "frc971.control_loops.drivetrain.Position",
       "source_node": "roborio",
@@ -30,11 +62,24 @@
         {
           "name": "logger",
           "priority": 2,
-          "time_to_live": 500000000
+          "time_to_live": 500000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ]
         }
       ]
     },
     {
+      "name": "/roborio/aos/remote_timestamps/logger/drivetrain/frc971-control_loops-drivetrain-Position",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "roborio",
+      "logger": "NOT_LOGGED",
+      "frequency": 400,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
       "name": "/drivetrain",
       "type": "frc971.control_loops.drivetrain.Output",
       "source_node": "roborio",
@@ -46,11 +91,24 @@
         {
           "name": "logger",
           "priority": 2,
-          "time_to_live": 500000000
+          "time_to_live": 500000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ]
         }
       ]
     },
     {
+      "name": "/roborio/aos/remote_timestamps/logger/drivetrain/frc971-control_loops-drivetrain-Output",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "roborio",
+      "logger": "NOT_LOGGED",
+      "frequency": 400,
+      "num_senders": 2,
+      "max_size": 400
+    },
+    {
       "name": "/pi1/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "pi1",
@@ -140,7 +198,7 @@
       "name": "/logger/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "logger",
-      "frequency": 10,
+      "frequency": 20,
       "max_size": 2000,
       "num_senders": 2
     },
@@ -148,8 +206,13 @@
       "name": "/logger/aos",
       "type": "aos.starter.Status",
       "source_node": "logger",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
       "frequency": 50,
       "num_senders": 20,
+      "max_size": 2000,
+      "logger_nodes": [
+        "roborio"
+      ],
       "destination_nodes": [
         {
           "name": "roborio",
@@ -175,6 +238,10 @@
       "name": "/logger/aos",
       "type": "aos.starter.StarterRpc",
       "source_node": "logger",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "roborio"
+      ],
       "frequency": 10,
       "num_senders": 2,
       "destination_nodes": [
@@ -322,6 +389,14 @@
       "max_size": 200
     },
     {
+      "name": "/logger/camera",
+      "type": "frc971.vision.CameraImage",
+      "source_node": "logger",
+      "frequency": 100,
+      "max_size": 620000,
+      "num_senders": 1
+    },
+    {
       "name": "/pi1/camera/decimated",
       "type": "frc971.vision.CameraImage",
       "source_node": "pi1",
@@ -395,7 +470,17 @@
       "rename": {
         "name": "/logger/aos"
       }
+    },
+    {
+      "match": {
+        "name": "/camera",
+        "source_node": "logger"
+      },
+      "rename": {
+        "name": "/logger/camera"
+      }
     }
+
   ],
   "applications": [
     {
@@ -421,6 +506,20 @@
       "nodes": [
         "logger"
       ]
+    },
+    {
+      "name": "image_streamer",
+      "executable_name": "image_streamer_start.sh",
+      "nodes": [
+        "logger"
+      ]
+    },
+    {
+      "name": "ball_color_detector",
+      "executable_name": "ball_color_detector",
+      "nodes": [
+        "logger"
+      ]
     }
   ],
   "nodes": [
diff --git a/y2022/y2022_pi_template.json b/y2022/y2022_pi_template.json
index 3dff81e..bcd3f6b 100644
--- a/y2022/y2022_pi_template.json
+++ b/y2022/y2022_pi_template.json
@@ -21,6 +21,12 @@
       "source_node": "pi{{ NUM }}",
       "frequency": 50,
       "num_senders": 20,
+      "max_size": 2000,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "roborio",
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "roborio",
@@ -40,6 +46,11 @@
       "source_node": "pi{{ NUM }}",
       "frequency": 10,
       "num_senders": 2,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "roborio",
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "roborio",
@@ -64,7 +75,7 @@
       "name": "/pi{{ NUM }}/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "pi{{ NUM }}",
-      "frequency": 10,
+      "frequency": 20,
       "num_senders": 2
     },
     {
@@ -118,6 +129,10 @@
       "name": "/imu/aos",
       "type": "aos.message_bridge.Timestamp",
       "source_node": "imu",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "pi{{ NUM }}"
+      ],
       "destination_nodes": [
         {
           "name": "pi{{ NUM }}",
@@ -166,7 +181,7 @@
       "source_node": "pi{{ NUM }}",
       "frequency": 25,
       "num_senders": 2,
-      "max_size": 20000,
+      "max_size": 40000,
       "logger": "LOCAL_AND_REMOTE_LOGGER",
       "logger_nodes": [
         "imu",
@@ -196,14 +211,14 @@
     {
       "name": "/pi{{ NUM }}/aos/remote_timestamps/imu/pi{{ NUM }}/camera/y2022-vision-TargetEstimate",
       "type": "aos.message_bridge.RemoteMessage",
-      "frequency": 20,
+      "frequency": 40,
       "source_node": "pi{{ NUM }}",
       "max_size": 208
     },
     {
       "name": "/pi{{ NUM }}/aos/remote_timestamps/logger/pi{{ NUM }}/camera/y2022-vision-TargetEstimate",
       "type": "aos.message_bridge.RemoteMessage",
-      "frequency": 20,
+      "frequency": 40,
       "source_node": "pi{{ NUM }}",
       "max_size": 208
     },
@@ -215,11 +230,24 @@
         {
           "name": "pi{{ NUM }}",
           "priority": 5,
-          "time_to_live": 5000000
+          "time_to_live": 5000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "imu"
+          ]
         }
       ]
     },
     {
+      "name": "/imu/aos/remote_timestamps/pi{{ NUM }}/localizer/frc971-controls-LocalizerOutput",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "imu",
+      "logger": "NOT_LOGGED",
+      "frequency": 400,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
       "name": "/logger/aos",
       "type": "aos.starter.StarterRpc",
       "source_node": "logger",
@@ -324,6 +352,7 @@
     {
       "name": "message_bridge_client",
       "executable_name": "message_bridge_client",
+      "args": ["--rt_priority=16"],
       "nodes": [
         "pi{{ NUM }}"
       ]
diff --git a/y2022/y2022_roborio.json b/y2022/y2022_roborio.json
index 6e14bae..8651923 100644
--- a/y2022/y2022_roborio.json
+++ b/y2022/y2022_roborio.json
@@ -4,7 +4,8 @@
       "name": "/roborio/aos",
       "type": "aos.JoystickState",
       "source_node": "roborio",
-      "frequency": 75,
+      "frequency": 100,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
       "logger_nodes" : [
         "imu"
       ],
@@ -12,11 +13,24 @@
         {
           "name": "imu",
           "priority": 5,
-          "time_to_live": 50000000
+          "time_to_live": 50000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ]
         }
       ]
     },
     {
+      "name": "/roborio/aos/remote_timestamps/imu/roborio/aos/aos-JoystickState",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "roborio",
+      "logger": "NOT_LOGGED",
+      "frequency": 200,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
       "name": "/roborio/aos",
       "type": "aos.RobotState",
       "source_node": "roborio",
@@ -44,6 +58,11 @@
       "source_node": "roborio",
       "frequency": 50,
       "num_senders": 20,
+      "max_size": 2000,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "logger",
@@ -72,6 +91,10 @@
       "frequency": 10,
       "max_size": 400,
       "num_senders": 2,
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_nodes": [
+        "logger"
+      ],
       "destination_nodes": [
         {
           "name": "logger",
@@ -104,7 +127,7 @@
       "name": "/roborio/aos",
       "type": "aos.message_bridge.ClientStatistics",
       "source_node": "roborio",
-      "frequency": 15,
+      "frequency": 20,
       "max_size": 2000,
       "num_senders": 2
     },
@@ -217,7 +240,7 @@
       "name": "/superstructure",
       "type": "y2022.control_loops.superstructure.Status",
       "source_node": "roborio",
-      "frequency": 200,
+      "frequency": 400,
       "num_senders": 2,
       "logger": "LOCAL_AND_REMOTE_LOGGER",
       "logger_nodes": [
@@ -228,16 +251,42 @@
         {
           "name": "imu",
           "priority": 5,
-          "time_to_live": 50000000
+          "time_to_live": 50000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ]
         },
         {
           "name": "logger",
           "priority": 5,
-          "time_to_live": 50000000
+          "time_to_live": 50000000,
+          "timestamp_logger": "LOCAL_AND_REMOTE_LOGGER",
+          "timestamp_logger_nodes": [
+            "roborio"
+          ]
         }
       ]
     },
     {
+      "name": "/roborio/aos/remote_timestamps/imu/superstructure/y2022-control_loops-superstructure-Status",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "roborio",
+      "logger": "NOT_LOGGED",
+      "frequency": 400,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
+      "name": "/roborio/aos/remote_timestamps/logger/superstructure/y2022-control_loops-superstructure-Status",
+      "type": "aos.message_bridge.RemoteMessage",
+      "source_node": "roborio",
+      "logger": "NOT_LOGGED",
+      "frequency": 400,
+      "num_senders": 2,
+      "max_size": 200
+    },
+    {
       "name": "/superstructure",
       "type": "y2022.control_loops.superstructure.Output",
       "source_node": "roborio",
@@ -268,6 +317,21 @@
       "num_senders": 2
     },
     {
+      "name": "/superstructure",
+      "type": "y2022.vision.BallColor",
+      "source_node": "logger",
+      "frequency": 200,
+      "num_senders": 2,
+      "max_size": 72,
+      "destination_nodes": [
+        {
+          "name": "roborio",
+          "priority": 2,
+          "time_to_live": 500000000
+        }
+      ]
+    },
+    {
       "name": "/drivetrain",
       "type": "frc971.sensors.GyroReading",
       "source_node": "roborio",
@@ -309,7 +373,7 @@
       "name": "/drivetrain",
       "type": "frc971.control_loops.drivetrain.Position",
       "source_node": "roborio",
-      "frequency": 200,
+      "frequency": 400,
       "max_size": 112,
       "num_senders": 2
     },
@@ -317,7 +381,7 @@
       "name": "/drivetrain",
       "type": "frc971.control_loops.drivetrain.Output",
       "source_node": "roborio",
-      "frequency": 200,
+      "frequency": 400,
       "max_size": 80,
       "num_senders": 2,
       "logger": "LOCAL_AND_REMOTE_LOGGER",
@@ -341,7 +405,7 @@
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "roborio",
       "logger": "NOT_LOGGED",
-      "frequency": 200,
+      "frequency": 400,
       "num_senders": 2,
       "max_size": 200
     },
@@ -349,7 +413,7 @@
       "name": "/drivetrain",
       "type": "frc971.control_loops.drivetrain.Status",
       "source_node": "roborio",
-      "frequency": 200,
+      "frequency": 400,
       "max_size": 1616,
       "num_senders": 2
     },
@@ -380,7 +444,7 @@
       "type": "aos.message_bridge.RemoteMessage",
       "source_node": "roborio",
       "logger": "NOT_LOGGED",
-      "frequency": 200,
+      "frequency": 400,
       "num_senders": 2,
       "max_size": 200
     },
@@ -471,8 +535,8 @@
       ]
     },
     {
-      "name": "message_bridge_client",
-      "executable_name": "message_bridge_client",
+      "name": "roborio_message_bridge_client",
+      "executable_name": "message_bridge_client.sh",
       "args": ["--rt_priority=16"],
       "nodes": [
         "roborio"